home *** CD-ROM | disk | FTP | other *** search
/ The Complete Utilities To…ka 501 Killer Utilities! / 501 Killer Utilities! (Macworld July 1995).cdr / Programming / OutOfPhase1.1 Source / OutOfPhase Folder / BuildInstrument.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-08  |  173.1 KB  |  5,488 lines  |  [TEXT/KAHL]
  1. /* BuildInstrument.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "BuildInstrument.h"
  31. #include "Memory.h"
  32. #include "TrashTracker.h"
  33. #include "CompilerScanner.h"
  34. #include "InstrumentStructure.h"
  35. #include "OscillatorSpecifier.h"
  36. #include "OscillatorListSpecifier.h"
  37. #include "LFOSpecifier.h"
  38. #include "LFOListSpecifier.h"
  39. #include "FixedPoint.h"
  40. #include "DataMunging.h"
  41. #include "Envelope.h"
  42. #include "SampleSelector.h"
  43. #include "EffectSpecList.h"
  44. #include "DelayEffectSpec.h"
  45. #include "WaveTableList.h"
  46. #include "AlgoWaveTableList.h"
  47. #include "NonlinearProcSpec.h"
  48. #include "FilterSpec.h"
  49. #include "AnalyzerSpec.h"
  50.  
  51.  
  52.  
  53.  
  54. #define OPAREN "("
  55. #define CPAREN ")"
  56.  
  57.  
  58.  
  59.  
  60. #define INSTRLIST_ONCEONLY_LOUDNESS (1L << 0)
  61.  
  62. #define INSTRLIST_REQUIRED_OSCILLATOR (1L << 0)
  63. #define INSTRLIST_REQUIREDMASK (INSTRLIST_REQUIRED_OSCILLATOR)
  64.  
  65.  
  66. #define LFODEFINITION_ONCEONLY_FREQENVELOPE (1L << 0)
  67. #define LFODEFINITION_ONCEONLY_AMPENVELOPE (1L << 1)
  68. #define LFODEFINITION_ONCEONLY_OSCILLATORTYPE (1L << 2)
  69. #define LFODEFINITION_ONCEONLY_MODULATIONTYPE (1L << 3)
  70. #define LFODEFINITION_ONCEONLY_ADDINGMODE (1L << 4)
  71.  
  72. #define LFODEFINITION_REQUIRED_AMPENVELOPE (1L << 0)
  73. #define LFODEFINITION_REQUIREDMASK (LFODEFINITION_REQUIRED_AMPENVELOPE)
  74.  
  75.  
  76. #define OSCILLATORDEFINITION_ONCEONLY_TYPE (1L << 0)
  77. #define OSCILLATORDEFINITION_ONCEONLY_SAMPLELIST (1L << 1)
  78. #define OSCILLATORDEFINITION_ONCEONLY_LOUDNESS (1L << 3)
  79. #define OSCILLATORDEFINITION_ONCEONLY_FREQMULTIPLIER (1L << 4)
  80. #define OSCILLATORDEFINITION_ONCEONLY_FREQDIVISOR (1L << 5)
  81. #define OSCILLATORDEFINITION_ONCEONLY_LOUDNESSENVELOPE (1L << 7)
  82. #define OSCILLATORDEFINITION_ONCEONLY_INDEXENVELOPE (1L << 8)
  83. #define OSCILLATORDEFINITION_ONCEONLY_STEREOBIAS (1L << 9)
  84. #define OSCILLATORDEFINITION_ONCEONLY_TIMEDISPLACEMENT (1L << 10)
  85. #define OSCILLATORDEFINITION_ONCEONLY_SURROUNDBIAS (1L << 11)
  86. #define OSCILLATORDEFINITION_ONCEONLY_FREQADDER (1L << 12)
  87.  
  88. #define OSCILLATORDEFINITION_REQUIRED_TYPE (1L << 0)
  89. #define OSCILLATORDEFINITION_REQUIRED_LOUDNESSENVELOPE (1L << 1)
  90. #define OSCILLATORDEFINITION_REQUIRED_SAMPLELIST (1L << 2)
  91.  
  92. #define OSCILLATORDEFINITION_REQUIREDMASK (OSCILLATORDEFINITION_REQUIRED_TYPE\
  93.                     | OSCILLATORDEFINITION_REQUIRED_LOUDNESSENVELOPE\
  94.                     | OSCILLATORDEFINITION_REQUIRED_SAMPLELIST)
  95.  
  96.  
  97. #define ENVELOPEDEFINITION_ONCEONLY_TOTALSCALING (1L << 1)
  98. #define ENVELOPEDEFINITION_ONCEONLY_POINTS (1L << 2)
  99.  
  100. #define ENVELOPEDEFINITION_REQUIREDMASK (0L)
  101.  
  102.  
  103. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT1 (1L << 0)
  104. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT2 (1L << 1)
  105. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT3 (1L << 2)
  106. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT4 (1L << 3)
  107. #define ENVPOINTDEFINITION_ONCEONLY_AMPFREQ (1L << 4)
  108. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT1 (1L << 5)
  109. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT2 (1L << 6)
  110. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT3 (1L << 7)
  111. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT4 (1L << 8)
  112. #define ENVPOINTDEFINITION_ONCEONLY_RATEFREQ (1L << 9)
  113. #define ENVPOINTDEFINITION_ONCEONLY_CURVE (1L << 10)
  114.  
  115.  
  116. #define DELAYEFFECT_ONCEONLY_MAXDELAYTIME (1L << 0)
  117.  
  118.  
  119. #define DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT1 (1L << 0)
  120. #define DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT2 (1L << 1)
  121. #define DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT3 (1L << 2)
  122. #define DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT4 (1L << 3)
  123. #define DELAYEFFECTATTR_ONCEONLY_TARGETACCENT1 (1L << 4)
  124. #define DELAYEFFECTATTR_ONCEONLY_TARGETACCENT2 (1L << 5)
  125. #define DELAYEFFECTATTR_ONCEONLY_TARGETACCENT3 (1L << 6)
  126. #define DELAYEFFECTATTR_ONCEONLY_TARGETACCENT4 (1L << 7)
  127. #define DELAYEFFECTATTR_ONCEONLY_SCALEACCENT1 (1L << 8)
  128. #define DELAYEFFECTATTR_ONCEONLY_SCALEACCENT2 (1L << 9)
  129. #define DELAYEFFECTATTR_ONCEONLY_SCALEACCENT3 (1L << 10)
  130. #define DELAYEFFECTATTR_ONCEONLY_SCALEACCENT4 (1L << 11)
  131. #define DELAYEFFECTATTR_ONCEONLY_FILTER (1L << 12)
  132.  
  133.  
  134. #define NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT1 (1L << 0)
  135. #define NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT2 (1L << 1)
  136. #define NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT3 (1L << 2)
  137. #define NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT4 (1L << 3)
  138. #define NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT1 (1L << 4)
  139. #define NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT2 (1L << 5)
  140. #define NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT3 (1L << 6)
  141. #define NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT4 (1L << 7)
  142. #define NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT1 (1L << 4)
  143. #define NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT2 (1L << 5)
  144. #define NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT3 (1L << 6)
  145. #define NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT4 (1L << 7)
  146.  
  147.  
  148. #define FILTEREFFECTATTR_ONCEONLY_FREQACCENT1 (1L << 0)
  149. #define FILTEREFFECTATTR_ONCEONLY_FREQACCENT2 (1L << 1)
  150. #define FILTEREFFECTATTR_ONCEONLY_FREQACCENT3 (1L << 2)
  151. #define FILTEREFFECTATTR_ONCEONLY_FREQACCENT4 (1L << 3)
  152. #define FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT1 (1L << 4)
  153. #define FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT2 (1L << 5)
  154. #define FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT3 (1L << 6)
  155. #define FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT4 (1L << 7)
  156. #define FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALING (1L << 8)
  157. #define FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT1 (1L << 9)
  158. #define FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT2 (1L << 10)
  159. #define FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT3 (1L << 11)
  160. #define FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT4 (1L << 12)
  161.  
  162.  
  163.  
  164.  
  165. /* prototypes */
  166. static BuildInstrErrors            ParseInstrDefinition(InstrumentRec* Instrument,
  167.                                                             ScannerRec* Scanner, long* ErrorLine,
  168.                                                             struct SampleListRec* SampleList,
  169.                                                             struct AlgoSampListRec* AlgoSampList,
  170.                                                             struct WaveTableListRec* WaveTableList,
  171.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  172. static BuildInstrErrors            ParseInstrList(InstrumentRec* Instrument,
  173.                                                             ScannerRec* Scanner, long* ErrorLine,
  174.                                                             unsigned long* RequiredDefinitions,
  175.                                                             unsigned long OnceOnlyDefinitions,
  176.                                                             struct SampleListRec* SampleList,
  177.                                                             struct AlgoSampListRec* AlgoSampList,
  178.                                                             struct WaveTableListRec* WaveTableList,
  179.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  180. static BuildInstrErrors            ParseInstrElem(InstrumentRec* Instrument,
  181.                                                             ScannerRec* Scanner, long* ErrorLine,
  182.                                                             unsigned long* RequiredDefinitions,
  183.                                                             unsigned long* OnceOnlyDefinitions,
  184.                                                             struct SampleListRec* SampleList,
  185.                                                             struct AlgoSampListRec* AlgoSampList,
  186.                                                             struct WaveTableListRec* WaveTableList,
  187.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  188. static BuildInstrErrors            ParseNumber(ScannerRec* Scanner, long* ErrorLine,
  189.                                                             double* NumberOut);
  190. static BuildInstrErrors            ParseLfoDefinition(LFOSpecRec* LFO, ScannerRec* Scanner,
  191.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  192.                                                             unsigned long OnceOnlyDefinitions,
  193.                                                             struct WaveTableListRec* WaveTableList,
  194.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  195. static BuildInstrErrors            ParseIdentifier(ScannerRec* Scanner, long* ErrorLine,
  196.                                                             char** IdentifierOut);
  197. static BuildInstrErrors            ParseOscillatorDefinition(OscillatorRec* Oscillator,
  198.                                                             ScannerRec* Scanner, long* ErrorLine,
  199.                                                             unsigned long* RequiredDefinitions,
  200.                                                             unsigned long OnceOnlyDefinitions,
  201.                                                             struct WaveTableListRec* WaveTableList,
  202.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  203. static BuildInstrErrors            ParseLfoElem(LFOSpecRec* LFO, ScannerRec* Scanner,
  204.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  205.                                                             unsigned long* OnceOnlyDefinitions,
  206.                                                             struct WaveTableListRec* WaveTableList,
  207.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  208. static BuildInstrErrors            ParseOscillatorElem(OscillatorRec* Oscillator,
  209.                                                             ScannerRec* Scanner, long* ErrorLine,
  210.                                                             unsigned long* RequiredDefinitions,
  211.                                                             unsigned long* OnceOnlyDefinitions,
  212.                                                             struct WaveTableListRec* WaveTableList,
  213.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  214. static BuildInstrErrors            ParseEnvelopeDefinition(EnvelopeRec* Envelope,
  215.                                                             ScannerRec* Scanner, long* ErrorLine,
  216.                                                             unsigned long* RequiredDefinitions,
  217.                                                             unsigned long OnceOnlyDefinitions);
  218. static BuildInstrErrors            ParseSamplelistDefinition(SampleSelectorRec* SampleList,
  219.                                                             ScannerRec* Scanner, long* ErrorLine);
  220. static BuildInstrErrors            ParseEnvelopeElem(EnvelopeRec* Envelope,
  221.                                                             ScannerRec* Scanner, long *ErrorLine,
  222.                                                             unsigned long* RequiredDefinitions,
  223.                                                             unsigned long* OnceOnlyDefinitions);
  224. static BuildInstrErrors            ParseSamplelistElem(SampleSelectorRec* SampleList,
  225.                                                             ScannerRec* Scanner, long* ErrorLine);
  226. static BuildInstrErrors            ParseEnvPointList(EnvelopeRec* Envelope,
  227.                                                             ScannerRec* Scanner, long *ErrorLine);
  228. static BuildInstrErrors            ParseEnvPointElem(EnvelopeRec* Envelope,
  229.                                                             ScannerRec* Scanner, long *ErrorLine);
  230. static BuildInstrErrors            ParseEnvAttributes(EnvelopeRec* Envelope,
  231.                                                             ScannerRec* Scanner, long *ErrorLine,
  232.                                                             unsigned long OnceOnly);
  233. static BuildInstrErrors            ParseEnvOneAttribute(EnvelopeRec* Envelope,
  234.                                                             ScannerRec* Scanner, long *ErrorLine,
  235.                                                             unsigned long* OnceOnlyDefinitions);
  236. static BuildInstrErrors            ParseTrackEffect(EffectSpecListRec* EffectList,
  237.                                                             ScannerRec* Scanner, long *ErrorLine,
  238.                                                             WaveTableListRec* WaveTableList,
  239.                                                             AlgoWaveTableListRec* AlgoWaveTableList);
  240. static BuildInstrErrors            ParseDelayElemList(DelayEffectRec* DelayEffect,
  241.                                                             ScannerRec* Scanner, long *ErrorLine,
  242.                                                             unsigned long* OnceOnlyDefinitions);
  243. static BuildInstrErrors            ParseDelayElem(DelayEffectRec* DelayEffect,
  244.                                                             ScannerRec* Scanner, long *ErrorLine,
  245.                                                             unsigned long* OnceOnlyDefinitions);
  246. static BuildInstrErrors            ParseTapAttributes(DelayTapRec* Tap,
  247.                                                             ScannerRec* Scanner, long *ErrorLine,
  248.                                                             unsigned long* OnceOnlyDefinitions);
  249. static BuildInstrErrors            ParseTapAttr(DelayTapRec* Tap,
  250.                                                             ScannerRec* Scanner, long *ErrorLine,
  251.                                                             unsigned long* OnceOnlyDefinitions);
  252. static BuildInstrErrors            ParseNLAttributes(NonlinProcSpecRec* NLProcSpec,
  253.                                                             ScannerRec* Scanner, long *ErrorLine,
  254.                                                             unsigned long* OnceOnlyDefinitions);
  255. static BuildInstrErrors            ParseFilterList(FilterSpecRec* FilterSpec,
  256.                                                             ScannerRec* Scanner, long *ErrorLine);
  257. static BuildInstrErrors            ParseFilter(FilterSpecRec* FilterSpec,
  258.                                                             ScannerRec* Scanner, long *ErrorLine);
  259. static BuildInstrErrors            ParseFilterAttributes(OneFilterRec* FilterElement,
  260.                                                             ScannerRec* Scanner, long *ErrorLine,
  261.                                                             unsigned long* OnceOnlyDefinitions,
  262.                                                             FilterTypes FilterType);
  263. static BuildInstrErrors            ParseFilterAttr(OneFilterRec* FilterElement,
  264.                                                             ScannerRec* Scanner, long *ErrorLine,
  265.                                                             unsigned long* OnceOnlyDefinitions,
  266.                                                             FilterTypes FilterType);
  267.  
  268.  
  269.  
  270.  
  271. /* token enumeration definitions */
  272. typedef enum
  273.     {
  274.         eKeywordInstrument EXECUTE(= -1274),
  275.         eKeywordLoudness,
  276.         eKeywordFrequencylfo,
  277.         eKeywordOscillator,
  278.         eKeywordFreqenvelope,
  279.         eKeywordModulation,
  280.         eKeywordConstant,
  281.         eKeywordSignsine,
  282.         eKeywordPlussine,
  283.         eKeywordSigntriangle,
  284.         eKeywordPlustriangle,
  285.         eKeywordSignsquare,
  286.         eKeywordPlussquare,
  287.         eKeywordSignramp,
  288.         eKeywordPlusramp,
  289.         eKeywordSignlinfuzz,
  290.         eKeywordPluslinfuzz,
  291.         eKeywordAdditive,
  292.         eKeywordMultiplicative,
  293.         eKeywordInversemult,
  294.         eKeywordType,
  295.         eKeywordSampled,
  296.         eKeywordWavetable,
  297.         eKeywordSamplelist,
  298.         eKeywordFreqmultiplier,
  299.         eKeywordFreqdivisor,
  300.         eKeywordFreqadder,
  301.         eKeywordLoudnessenvelope,
  302.         eKeywordTotalscaling,
  303.         eKeywordExponential,
  304.         eKeywordLinear,
  305.         eKeywordLevel,
  306.         eKeywordDelay,
  307.         eKeywordSustainpoint,
  308.         eKeywordReleasepoint,
  309.         eKeywordSustainpointnoskip,
  310.         eKeywordReleasepointnoskip,
  311.         eKeywordAmpaccent1,
  312.         eKeywordAmpaccent2,
  313.         eKeywordAmpaccent3,
  314.         eKeywordAmpaccent4,
  315.         eKeywordAmpfreq,
  316.         eKeywordRateaccent1,
  317.         eKeywordRateaccent2,
  318.         eKeywordRateaccent3,
  319.         eKeywordRateaccent4,
  320.         eKeywordRatefreq,
  321.         eKeywordScale,
  322.         eKeywordAmpenvelope,
  323.         eKeywordLoudnesslfo,
  324.         eKeywordIndexenvelope,
  325.         eKeywordIndexlfo,
  326.         eKeywordPoints,
  327.         eKeywordStereobias,
  328.         eKeywordDisplacement,
  329.         eKeywordSurroundbias,
  330.         eKeywordHertz,
  331.         eKeywordOrigin,
  332.         eKeywordHalfsteps,
  333.         eKeywordSquare,
  334.         eKeywordTriangle,
  335.         eKeywordTrackeffect,
  336.         eKeywordTap,
  337.         eKeywordTo,
  338.         eKeywordSourceaccent1,
  339.         eKeywordSourceaccent2,
  340.         eKeywordSourceaccent3,
  341.         eKeywordSourceaccent4,
  342.         eKeywordTargetaccent1,
  343.         eKeywordTargetaccent2,
  344.         eKeywordTargetaccent3,
  345.         eKeywordTargetaccent4,
  346.         eKeywordScaleaccent1,
  347.         eKeywordScaleaccent2,
  348.         eKeywordScaleaccent3,
  349.         eKeywordScaleaccent4,
  350.         eKeywordMovingaveragelowpass,
  351.         eKeywordLeft,
  352.         eKeywordRight,
  353.         eKeywordMono,
  354.         eKeywordDelayline,
  355.         eKeywordMaxdelaytime,
  356.         eKeywordSlope,
  357.         eKeywordCenter,
  358.         eKeywordEnvelope,
  359.         eKeywordNlproc,
  360.         eKeywordInputscaling,
  361.         eKeywordOutputscaling,
  362.         eKeywordInputaccent1,
  363.         eKeywordInputaccent2,
  364.         eKeywordInputaccent3,
  365.         eKeywordInputaccent4,
  366.         eKeywordOutputaccent1,
  367.         eKeywordOutputaccent2,
  368.         eKeywordOutputaccent3,
  369.         eKeywordOutputaccent4,
  370.         eKeywordWavetableindex,
  371.         eKeywordIndexaccent1,
  372.         eKeywordIndexaccent2,
  373.         eKeywordIndexaccent3,
  374.         eKeywordIndexaccent4,
  375.         eKeywordFilter,
  376.         eKeywordFreq,
  377.         eKeywordBandwidth,
  378.         eKeywordDefaultscaling,
  379.         eKeywordUnitymidbandgain,
  380.         eKeywordUnitynoisegain,
  381.         eKeywordUnityzerohertzgain,
  382.         eKeywordLowpass,
  383.         eKeywordHighpass,
  384.         eKeywordReson,
  385.         eKeywordZero,
  386.         eKeywordButterworthlowpass,
  387.         eKeywordButterworthhighpass,
  388.         eKeywordButterworthbandpass,
  389.         eKeywordButterworthbandreject,
  390.         eKeywordFreqaccent1,
  391.         eKeywordFreqaccent2,
  392.         eKeywordFreqaccent3,
  393.         eKeywordFreqaccent4,
  394.         eKeywordBandwidthaccent1,
  395.         eKeywordBandwidthaccent2,
  396.         eKeywordBandwidthaccent3,
  397.         eKeywordBandwidthaccent4,
  398.         eKeywordNull,
  399.         eKeywordAnalyzer,
  400.         eKeywordScoreeffect,
  401.         eKeywordEffect
  402.     } KeywordType;
  403.  
  404.  
  405.  
  406.  
  407. /* load keywords into scanner */
  408. static void                                    LoadScannerKeywords(ScannerRec* Scanner)
  409.     {
  410.         AddKeywordToScanner(Scanner,"instrument",eKeywordInstrument);
  411.         AddKeywordToScanner(Scanner,"loudness",eKeywordLoudness);
  412.         AddKeywordToScanner(Scanner,"frequencylfo",eKeywordFrequencylfo);
  413.         AddKeywordToScanner(Scanner,"oscillator",eKeywordOscillator);
  414.         AddKeywordToScanner(Scanner,"freqenvelope",eKeywordFreqenvelope);
  415.         AddKeywordToScanner(Scanner,"modulation",eKeywordModulation);
  416.         AddKeywordToScanner(Scanner,"constant",eKeywordConstant);
  417.         AddKeywordToScanner(Scanner,"signsine",eKeywordSignsine);
  418.         AddKeywordToScanner(Scanner,"plussine",eKeywordPlussine);
  419.         AddKeywordToScanner(Scanner,"signtriangle",eKeywordSigntriangle);
  420.         AddKeywordToScanner(Scanner,"plustriangle",eKeywordPlustriangle);
  421.         AddKeywordToScanner(Scanner,"signsquare",eKeywordSignsquare);
  422.         AddKeywordToScanner(Scanner,"plussquare",eKeywordPlussquare);
  423.         AddKeywordToScanner(Scanner,"signramp",eKeywordSignramp);
  424.         AddKeywordToScanner(Scanner,"plusramp",eKeywordPlusramp);
  425.         AddKeywordToScanner(Scanner,"signlinfuzz",eKeywordSignlinfuzz);
  426.         AddKeywordToScanner(Scanner,"pluslinfuzz",eKeywordPluslinfuzz);
  427.         AddKeywordToScanner(Scanner,"additive",eKeywordAdditive);
  428.         AddKeywordToScanner(Scanner,"multiplicative",eKeywordMultiplicative);
  429.         AddKeywordToScanner(Scanner,"inversemult",eKeywordInversemult);
  430.         AddKeywordToScanner(Scanner,"type",eKeywordType);
  431.         AddKeywordToScanner(Scanner,"sampled",eKeywordSampled);
  432.         AddKeywordToScanner(Scanner,"wavetable",eKeywordWavetable);
  433.         AddKeywordToScanner(Scanner,"samplelist",eKeywordSamplelist);
  434.         AddKeywordToScanner(Scanner,"freqmultiplier",eKeywordFreqmultiplier);
  435.         AddKeywordToScanner(Scanner,"freqdivisor",eKeywordFreqdivisor);
  436.         AddKeywordToScanner(Scanner,"freqadder",eKeywordFreqadder);
  437.         AddKeywordToScanner(Scanner,"loudnessenvelope",eKeywordLoudnessenvelope);
  438.         AddKeywordToScanner(Scanner,"totalscaling",eKeywordTotalscaling);
  439.         AddKeywordToScanner(Scanner,"exponential",eKeywordExponential);
  440.         AddKeywordToScanner(Scanner,"linear",eKeywordLinear);
  441.         AddKeywordToScanner(Scanner,"level",eKeywordLevel);
  442.         AddKeywordToScanner(Scanner,"delay",eKeywordDelay);
  443.         AddKeywordToScanner(Scanner,"sustainpoint",eKeywordSustainpoint);
  444.         AddKeywordToScanner(Scanner,"releasepoint",eKeywordReleasepoint);
  445.         AddKeywordToScanner(Scanner,"sustainpointnoskip",eKeywordSustainpointnoskip);
  446.         AddKeywordToScanner(Scanner,"releasepointnoskip",eKeywordReleasepointnoskip);
  447.         AddKeywordToScanner(Scanner,"ampaccent1",eKeywordAmpaccent1);
  448.         AddKeywordToScanner(Scanner,"ampaccent2",eKeywordAmpaccent2);
  449.         AddKeywordToScanner(Scanner,"ampaccent3",eKeywordAmpaccent3);
  450.         AddKeywordToScanner(Scanner,"ampaccent4",eKeywordAmpaccent4);
  451.         AddKeywordToScanner(Scanner,"ampfreq",eKeywordAmpfreq);
  452.         AddKeywordToScanner(Scanner,"rateaccent1",eKeywordRateaccent1);
  453.         AddKeywordToScanner(Scanner,"rateaccent2",eKeywordRateaccent2);
  454.         AddKeywordToScanner(Scanner,"rateaccent3",eKeywordRateaccent3);
  455.         AddKeywordToScanner(Scanner,"rateaccent4",eKeywordRateaccent4);
  456.         AddKeywordToScanner(Scanner,"ratefreq",eKeywordRatefreq);
  457.         AddKeywordToScanner(Scanner,"scale",eKeywordScale);
  458.         AddKeywordToScanner(Scanner,"ampenvelope",eKeywordAmpenvelope);
  459.         AddKeywordToScanner(Scanner,"loudnesslfo",eKeywordLoudnesslfo);
  460.         AddKeywordToScanner(Scanner,"indexenvelope",eKeywordIndexenvelope);
  461.         AddKeywordToScanner(Scanner,"indexlfo",eKeywordIndexlfo);
  462.         AddKeywordToScanner(Scanner,"points",eKeywordPoints);
  463.         AddKeywordToScanner(Scanner,"stereobias",eKeywordStereobias);
  464.         AddKeywordToScanner(Scanner,"displacement",eKeywordDisplacement);
  465.         AddKeywordToScanner(Scanner,"surroundbias",eKeywordSurroundbias);
  466.         AddKeywordToScanner(Scanner,"hertz",eKeywordHertz);
  467.         AddKeywordToScanner(Scanner,"origin",eKeywordOrigin);
  468.         AddKeywordToScanner(Scanner,"halfsteps",eKeywordHalfsteps);
  469.         AddKeywordToScanner(Scanner,"square",eKeywordSquare);
  470.         AddKeywordToScanner(Scanner,"triangle",eKeywordTriangle);
  471.         AddKeywordToScanner(Scanner,"trackeffect",eKeywordTrackeffect);
  472.         AddKeywordToScanner(Scanner,"tap",eKeywordTap);
  473.         AddKeywordToScanner(Scanner,"to",eKeywordTo);
  474.         AddKeywordToScanner(Scanner,"sourceaccent1",eKeywordSourceaccent1);
  475.         AddKeywordToScanner(Scanner,"sourceaccent2",eKeywordSourceaccent2);
  476.         AddKeywordToScanner(Scanner,"sourceaccent3",eKeywordSourceaccent3);
  477.         AddKeywordToScanner(Scanner,"sourceaccent4",eKeywordSourceaccent4);
  478.         AddKeywordToScanner(Scanner,"targetaccent1",eKeywordTargetaccent1);
  479.         AddKeywordToScanner(Scanner,"targetaccent2",eKeywordTargetaccent2);
  480.         AddKeywordToScanner(Scanner,"targetaccent3",eKeywordTargetaccent3);
  481.         AddKeywordToScanner(Scanner,"targetaccent4",eKeywordTargetaccent4);
  482.         AddKeywordToScanner(Scanner,"scaleaccent1",eKeywordScaleaccent1);
  483.         AddKeywordToScanner(Scanner,"scaleaccent2",eKeywordScaleaccent2);
  484.         AddKeywordToScanner(Scanner,"scaleaccent3",eKeywordScaleaccent3);
  485.         AddKeywordToScanner(Scanner,"scaleaccent4",eKeywordScaleaccent4);
  486.         AddKeywordToScanner(Scanner,"movingaveragelowpass",eKeywordMovingaveragelowpass);
  487.         AddKeywordToScanner(Scanner,"left",eKeywordLeft);
  488.         AddKeywordToScanner(Scanner,"right",eKeywordRight);
  489.         AddKeywordToScanner(Scanner,"mono",eKeywordMono);
  490.         AddKeywordToScanner(Scanner,"delayline",eKeywordDelayline);
  491.         AddKeywordToScanner(Scanner,"maxdelaytime",eKeywordMaxdelaytime);
  492.         AddKeywordToScanner(Scanner,"slope",eKeywordSlope);
  493.         AddKeywordToScanner(Scanner,"center",eKeywordCenter);
  494.         AddKeywordToScanner(Scanner,"envelope",eKeywordEnvelope);
  495.         AddKeywordToScanner(Scanner,"nlproc",eKeywordNlproc);
  496.         AddKeywordToScanner(Scanner,"inputscaling",eKeywordInputscaling);
  497.         AddKeywordToScanner(Scanner,"outputscaling",eKeywordOutputscaling);
  498.         AddKeywordToScanner(Scanner,"inputaccent1",eKeywordInputaccent1);
  499.         AddKeywordToScanner(Scanner,"inputaccent2",eKeywordInputaccent2);
  500.         AddKeywordToScanner(Scanner,"inputaccent3",eKeywordInputaccent3);
  501.         AddKeywordToScanner(Scanner,"inputaccent4",eKeywordInputaccent4);
  502.         AddKeywordToScanner(Scanner,"outputaccent1",eKeywordOutputaccent1);
  503.         AddKeywordToScanner(Scanner,"outputaccent2",eKeywordOutputaccent2);
  504.         AddKeywordToScanner(Scanner,"outputaccent3",eKeywordOutputaccent3);
  505.         AddKeywordToScanner(Scanner,"outputaccent4",eKeywordOutputaccent4);
  506.         AddKeywordToScanner(Scanner,"wavetableindex",eKeywordWavetableindex);
  507.         AddKeywordToScanner(Scanner,"indexaccent1",eKeywordIndexaccent1);
  508.         AddKeywordToScanner(Scanner,"indexaccent2",eKeywordIndexaccent2);
  509.         AddKeywordToScanner(Scanner,"indexaccent3",eKeywordIndexaccent3);
  510.         AddKeywordToScanner(Scanner,"indexaccent4",eKeywordIndexaccent4);
  511.         AddKeywordToScanner(Scanner,"filter",eKeywordFilter);
  512.         AddKeywordToScanner(Scanner,"freq",eKeywordFreq);
  513.         AddKeywordToScanner(Scanner,"bandwidth",eKeywordBandwidth);
  514.         AddKeywordToScanner(Scanner,"defaultscaling",eKeywordDefaultscaling);
  515.         AddKeywordToScanner(Scanner,"unitymidbandgain",eKeywordUnitymidbandgain);
  516.         AddKeywordToScanner(Scanner,"unitynoisegain",eKeywordUnitynoisegain);
  517.         AddKeywordToScanner(Scanner,"unityzerohertzgain",eKeywordUnityzerohertzgain);
  518.         AddKeywordToScanner(Scanner,"lowpass",eKeywordLowpass);
  519.         AddKeywordToScanner(Scanner,"highpass",eKeywordHighpass);
  520.         AddKeywordToScanner(Scanner,"reson",eKeywordReson);
  521.         AddKeywordToScanner(Scanner,"zero",eKeywordZero);
  522.         AddKeywordToScanner(Scanner,"butterworthlowpass",eKeywordButterworthlowpass);
  523.         AddKeywordToScanner(Scanner,"butterworthhighpass",eKeywordButterworthhighpass);
  524.         AddKeywordToScanner(Scanner,"butterworthbandpass",eKeywordButterworthbandpass);
  525.         AddKeywordToScanner(Scanner,"butterworthbandreject",eKeywordButterworthbandreject);
  526.         AddKeywordToScanner(Scanner,"freqaccent1",eKeywordFreqaccent1);
  527.         AddKeywordToScanner(Scanner,"freqaccent2",eKeywordFreqaccent2);
  528.         AddKeywordToScanner(Scanner,"freqaccent3",eKeywordFreqaccent3);
  529.         AddKeywordToScanner(Scanner,"freqaccent4",eKeywordFreqaccent4);
  530.         AddKeywordToScanner(Scanner,"bandwidthaccent1",eKeywordBandwidthaccent1);
  531.         AddKeywordToScanner(Scanner,"bandwidthaccent2",eKeywordBandwidthaccent2);
  532.         AddKeywordToScanner(Scanner,"bandwidthaccent3",eKeywordBandwidthaccent3);
  533.         AddKeywordToScanner(Scanner,"bandwidthaccent4",eKeywordBandwidthaccent4);
  534.         AddKeywordToScanner(Scanner,"null",eKeywordNull);
  535.         AddKeywordToScanner(Scanner,"analyzer",eKeywordAnalyzer);
  536.         AddKeywordToScanner(Scanner,"scoreeffect",eKeywordScoreeffect);
  537.         AddKeywordToScanner(Scanner,"effect",eKeywordEffect);
  538.     }
  539.  
  540.  
  541.  
  542.  
  543. /* take a block of text and parse it into an instrument definition.  it returns an */
  544. /* error code.  if an error occurs, then *InstrOut is invalid, otherwise it will */
  545. /* be valid.  the text file remains unaltered.  *ErrorLine is numbered from 1. */
  546. BuildInstrErrors                        BuildInstrumentFromText(char* TextFile, long* ErrorLine,
  547.                                                             struct InstrumentRec** InstrOut,
  548.                                                             struct SampleListRec* SampleList,
  549.                                                             struct AlgoSampListRec* AlgoSampList,
  550.                                                             struct WaveTableListRec* WaveTableList,
  551.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  552.     {
  553.         TrashTrackRec*                        TrashTracker;
  554.         ScannerRec*                                Scanner;
  555.         InstrumentRec*                        Instrument;
  556.         BuildInstrErrors                    Error;
  557.         TokenRec*                                    Token;
  558.  
  559.         CheckPtrExistence(TextFile);
  560.         CheckPtrExistence(SampleList);
  561.         CheckPtrExistence(AlgoSampList);
  562.         CheckPtrExistence(WaveTableList);
  563.         CheckPtrExistence(AlgoWaveTableList);
  564.         EXECUTE(*InstrOut = (InstrumentRec*)0x81818181;)
  565.         EXECUTE(*ErrorLine = 0x81818181;)
  566.  
  567.         TrashTracker = NewTrashTracker();
  568.         if (TrashTracker == NIL)
  569.             {
  570.              NoMemoryFailurePoint1:
  571.                 *ErrorLine = 1;
  572.                 return eBuildInstrOutOfMemory;
  573.             }
  574.  
  575.         Scanner = NewScanner(TrashTracker,TextFile);
  576.         if (Scanner == NIL)
  577.             {
  578.              NoMemoryFailurePoint2:
  579.                 goto NoMemoryFailurePoint1;
  580.             }
  581.  
  582.         Instrument = NewInstrumentSpecifier();
  583.         if (Instrument == NIL)
  584.             {
  585.              NoMemoryFailurePoint3:
  586.                 goto NoMemoryFailurePoint2;
  587.             }
  588.  
  589.         LoadScannerKeywords(Scanner);
  590.  
  591.         Error = ParseInstrDefinition(Instrument,Scanner,ErrorLine,SampleList,AlgoSampList,
  592.             WaveTableList,AlgoWaveTableList);
  593.         if (Error != eBuildInstrNoError)
  594.             {
  595.                 DisposeInstrumentSpecification(Instrument);
  596.                 DisposeTrashTracker(TrashTracker);
  597.                 return Error;
  598.             }
  599.  
  600.         Token = GetNextToken(Scanner);
  601.         if (Token == NIL)
  602.             {
  603.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  604.                 DisposeInstrumentSpecification(Instrument);
  605.                 DisposeTrashTracker(TrashTracker);
  606.                 return eBuildInstrOutOfMemory;
  607.             }
  608.         if (GetTokenType(Token) != eTokenEndOfInput)
  609.             {
  610.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  611.                 DisposeInstrumentSpecification(Instrument);
  612.                 DisposeTrashTracker(TrashTracker);
  613.                 return eBuildInstrUnexpectedInput;
  614.             }
  615.  
  616.         DisposeTrashTracker(TrashTracker);
  617.  
  618.         *InstrOut = Instrument;
  619.         return eBuildInstrNoError;
  620.     }
  621.  
  622.  
  623.  
  624.  
  625. /*    1:   <instr_definition>      ::= instrument ( <instr_list> ) */
  626. /* FIRST SET: */
  627. /*  <instr_definition>      : {instrument} */
  628. /* FOLLOW SET: */
  629. /*  <instr_definition>      : {$$$} */
  630. static BuildInstrErrors            ParseInstrDefinition(InstrumentRec* Instrument,
  631.                                                             ScannerRec* Scanner, long* ErrorLine,
  632.                                                             struct SampleListRec* SampleList,
  633.                                                             struct AlgoSampListRec* AlgoSampList,
  634.                                                             struct WaveTableListRec* WaveTableList,
  635.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  636.     {
  637.         TokenRec*                                    Token;
  638.         BuildInstrErrors                    Error;
  639.         unsigned long                            Required;
  640.  
  641.         CheckPtrExistence(Instrument);
  642.         CheckPtrExistence(Scanner);
  643.  
  644.         Token = GetNextToken(Scanner);
  645.         if (Token == NIL)
  646.             {
  647.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  648.                 return eBuildInstrOutOfMemory;
  649.             }
  650.         if ((GetTokenType(Token) != eTokenKeyword)
  651.             || (GetTokenKeywordTag(Token) != eKeywordInstrument))
  652.             {
  653.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  654.                 return eBuildInstrExpectedInstrument;
  655.             }
  656.  
  657.         Token = GetNextToken(Scanner);
  658.         if (Token == NIL)
  659.             {
  660.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  661.                 return eBuildInstrOutOfMemory;
  662.             }
  663.         if (GetTokenType(Token) != eTokenOpenParen)
  664.             {
  665.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  666.                 return eBuildInstrExpectedOpenParen;
  667.             }
  668.  
  669.         Required = 0;
  670.         Error = ParseInstrList(Instrument,Scanner,ErrorLine,&Required,0,SampleList,
  671.             AlgoSampList,WaveTableList,AlgoWaveTableList);
  672.         if (Error != eBuildInstrNoError)
  673.             {
  674.                 return Error;
  675.             }
  676.         if (Required != INSTRLIST_REQUIREDMASK)
  677.             {
  678.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  679.                 return eBuildInstrSomeRequiredInstrParamsMissing;
  680.             }
  681.  
  682.         Token = GetNextToken(Scanner);
  683.         if (Token == NIL)
  684.             {
  685.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  686.                 return eBuildInstrOutOfMemory;
  687.             }
  688.         if (GetTokenType(Token) != eTokenCloseParen)
  689.             {
  690.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  691.                 return eBuildInstrExpectedCloseParen;
  692.             }
  693.  
  694.         return eBuildInstrNoError;
  695.     }
  696.  
  697.  
  698.  
  699.  
  700. /*    2:   <instr_list>            ::= <instr_elem> ; <instr_list> */
  701. /*    3:                           ::=  */
  702. /* FIRST SET: */
  703. /*  <instr_list>            : {loudness, frequencylfo, oscillator, <instr_elem>} */
  704. /* FOLLOW SET: */
  705. /*  <instr_list>            : {)} */
  706. static BuildInstrErrors            ParseInstrList(InstrumentRec* Instrument,
  707.                                                             ScannerRec* Scanner, long* ErrorLine,
  708.                                                             unsigned long* RequiredDefinitions,
  709.                                                             unsigned long OnceOnlyDefinitions,
  710.                                                             struct SampleListRec* SampleList,
  711.                                                             struct AlgoSampListRec* AlgoSampList,
  712.                                                             struct WaveTableListRec* WaveTableList,
  713.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  714.     {
  715.         TokenRec*                                    Token;
  716.         BuildInstrErrors                    Error;
  717.  
  718.         CheckPtrExistence(Instrument);
  719.         CheckPtrExistence(Scanner);
  720.  
  721.         Token = GetNextToken(Scanner);
  722.         if (Token == NIL)
  723.             {
  724.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  725.                 return eBuildInstrOutOfMemory;
  726.             }
  727.  
  728.         if (GetTokenType(Token) == eTokenCloseParen)
  729.             {
  730.                 UngetToken(Scanner,Token);
  731.                 return eBuildInstrNoError;
  732.             }
  733.          else
  734.             {
  735.                 UngetToken(Scanner,Token);
  736.  
  737.                 Error = ParseInstrElem(Instrument,Scanner,ErrorLine,RequiredDefinitions,
  738.                     &OnceOnlyDefinitions,SampleList,AlgoSampList,WaveTableList,AlgoWaveTableList);
  739.                 if (Error != eBuildInstrNoError)
  740.                     {
  741.                         return Error;
  742.                     }
  743.  
  744.                 /* get semicolon */
  745.                 Token = GetNextToken(Scanner);
  746.                 if (Token == NIL)
  747.                     {
  748.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  749.                         return eBuildInstrOutOfMemory;
  750.                     }
  751.                 if (GetTokenType(Token) != eTokenSemicolon)
  752.                     {
  753.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  754.                         return eBuildInstrExpectedSemicolon;
  755.                     }
  756.  
  757.                 return ParseInstrList(Instrument,Scanner,ErrorLine,RequiredDefinitions,
  758.                     OnceOnlyDefinitions,SampleList,AlgoSampList,WaveTableList,AlgoWaveTableList);
  759.             }
  760.         EXECUTE(PRERR(ForceAbort,"ParseInstrList:  control reached end of function"));
  761.     }
  762.  
  763.  
  764.  
  765.  
  766. /*    4:   <instr_elem>            ::= loudness <number> */
  767. /*    5:                           ::= frequencylfo ( <lfo_definition> ) */
  768. /*    6:                           ::= oscillator <identifier> ( <oscillator_definition> ) */
  769. /*  XXX:                           ::= trackeffect <trackeffect> */
  770. /* FIRST SET: */
  771. /*  <instr_elem>            : {loudness, frequencylfo, oscillator} */
  772. /* FOLLOW SET: */
  773. /*  <instr_elem>            : {;} */
  774. static BuildInstrErrors            ParseInstrElem(InstrumentRec* Instrument,
  775.                                                             ScannerRec* Scanner, long* ErrorLine,
  776.                                                             unsigned long* RequiredDefinitions,
  777.                                                             unsigned long* OnceOnlyDefinitions,
  778.                                                             struct SampleListRec* SampleList,
  779.                                                             struct AlgoSampListRec* AlgoSampList,
  780.                                                             struct WaveTableListRec* WaveTableList,
  781.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  782.     {
  783.         TokenRec*                                    Token;
  784.         BuildInstrErrors                    Error;
  785.  
  786.         CheckPtrExistence(Instrument);
  787.         CheckPtrExistence(Scanner);
  788.  
  789.         Token = GetNextToken(Scanner);
  790.         if (Token == NIL)
  791.             {
  792.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  793.                 return eBuildInstrOutOfMemory;
  794.             }
  795.         if (GetTokenType(Token) != eTokenKeyword)
  796.             {
  797.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  798.                 return eBuildInstrExpectedInstrumentMember;
  799.             }
  800.  
  801.         if (GetTokenKeywordTag(Token) == eKeywordLoudness)
  802.             {
  803.                 double                                        Number;
  804.  
  805.                 if ((*OnceOnlyDefinitions & INSTRLIST_ONCEONLY_LOUDNESS) != 0)
  806.                     {
  807.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  808.                         return eBuildInstrMultipleInstrLoudness;
  809.                     }
  810.                 Error = ParseNumber(Scanner,ErrorLine,&Number);
  811.                 if (Error != eBuildInstrNoError)
  812.                     {
  813.                         return Error;
  814.                     }
  815.                 InstrumentSetOverallLoudness(Instrument,Number);
  816.                 *OnceOnlyDefinitions |= INSTRLIST_ONCEONLY_LOUDNESS;
  817.             }
  818.         else if (GetTokenKeywordTag(Token) == eKeywordFrequencylfo)
  819.             {
  820.                 unsigned long                            LFORequired;
  821.                 LFOSpecRec*                                LFO;
  822.  
  823.                 /* allocate the LFO */
  824.                 LFO = NewLFOSpecifier();
  825.                 if (LFO == NIL)
  826.                     {
  827.                      LFOAllocFailurePoint1:
  828.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  829.                         return eBuildInstrOutOfMemory;
  830.                     }
  831.                 /* the default arithmetic mode for pitch LFO is halfsteps */
  832.                 SetLFOSpecAddingMode(LFO,eLFOHalfSteps);
  833.                 if (!LFOListSpecAppendNewEntry(GetInstrumentFrequencyLFOList(Instrument),LFO))
  834.                     {
  835.                      LFOAllocFailurePoint2:
  836.                         DisposeLFOSpecifier(LFO);
  837.                         goto LFOAllocFailurePoint1;
  838.                     }
  839.  
  840.                 /* open paren */
  841.                 Token = GetNextToken(Scanner);
  842.                 if (Token == NIL)
  843.                     {
  844.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  845.                         return eBuildInstrOutOfMemory;
  846.                     }
  847.                 if (GetTokenType(Token) != eTokenOpenParen)
  848.                     {
  849.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  850.                         return eBuildInstrExpectedOpenParen;
  851.                     }
  852.  
  853.                 /* parse the low frequency operator */
  854.                 LFORequired = 0;
  855.                 Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&LFORequired,0,WaveTableList,
  856.                     AlgoWaveTableList);
  857.                 if (Error != eBuildInstrNoError)
  858.                     {
  859.                         return Error;
  860.                     }
  861.                 if (LFORequired != LFODEFINITION_REQUIREDMASK)
  862.                     {
  863.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  864.                         return eBuildInstrSomeRequiredLFOParamsMissing;
  865.                     }
  866.  
  867.                 /* close paren */
  868.                 Token = GetNextToken(Scanner);
  869.                 if (Token == NIL)
  870.                     {
  871.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  872.                         return eBuildInstrOutOfMemory;
  873.                     }
  874.                 if (GetTokenType(Token) != eTokenCloseParen)
  875.                     {
  876.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  877.                         return eBuildInstrExpectedCloseParen;
  878.                     }
  879.             }
  880.         else if (GetTokenKeywordTag(Token) == eKeywordOscillator)
  881.             {
  882.                 char*                                            Identifier;
  883.                 unsigned long                            OscillatorRequired;
  884.                 OscillatorRec*                        Oscillator;
  885.  
  886.                 /* allocate a new oscillator & add it to the instrument */
  887.                 Oscillator = NewOscillatorSpecifier();
  888.                 if (Oscillator == NIL)
  889.                     {
  890.                      OscillatorAllocFailurePoint1:
  891.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  892.                         return eBuildInstrOutOfMemory;
  893.                     }
  894.                 if (!AppendOscillatorToList(GetInstrumentOscillatorList(Instrument),Oscillator))
  895.                     {
  896.                      OscillatorAllocFailurePoint2:
  897.                         DisposeOscillatorSpecifier(Oscillator);
  898.                         goto OscillatorAllocFailurePoint1;
  899.                     }
  900.  
  901.                 /* get the oscillator's name */
  902.                 Token = GetNextToken(Scanner);
  903.                 if (Token == NIL)
  904.                     {
  905.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  906.                         return eBuildInstrOutOfMemory;
  907.                     }
  908.                 if (GetTokenType(Token) != eTokenOpenParen)
  909.                     {
  910.                         UngetToken(Scanner,Token);
  911.                         Error = ParseIdentifier(Scanner,ErrorLine,&Identifier);
  912.                         if (Error != eBuildInstrNoError)
  913.                             {
  914.                                 return Error;
  915.                             }
  916.                         CheckPtrExistence(Identifier);
  917.                         /* throw away oscillator name since we don't use them anymore */
  918.                         ReleasePtr(Identifier);
  919.                     }
  920.                  else
  921.                     {
  922.                         UngetToken(Scanner,Token);
  923.                     }
  924.  
  925.                 /* eat the open paren */
  926.                 Token = GetNextToken(Scanner);
  927.                 if (Token == NIL)
  928.                     {
  929.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  930.                         return eBuildInstrOutOfMemory;
  931.                     }
  932.                 if (GetTokenType(Token) != eTokenOpenParen)
  933.                     {
  934.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  935.                         return eBuildInstrExpectedOpenParen;
  936.                     }
  937.  
  938.                 /* parse oscillator */
  939.                 OscillatorRequired = 0;
  940.                 Error = ParseOscillatorDefinition(Oscillator,Scanner,ErrorLine,
  941.                     &OscillatorRequired,0,WaveTableList,AlgoWaveTableList);
  942.                 if (Error != eBuildInstrNoError)
  943.                     {
  944.                         return Error;
  945.                     }
  946.                 if (OscillatorRequired != OSCILLATORDEFINITION_REQUIREDMASK)
  947.                     {
  948.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  949.                         return eBuildInstrSomeRequiredOscillatorParamsMissing;
  950.                     }
  951.  
  952.                 /* resolve sample/wave table data references */
  953.                 switch (OscillatorGetWhatKindItIs(Oscillator))
  954.                     {
  955.                         default:
  956.                             EXECUTE(PRERR(ForceAbort,"ParseInstrElem:  bad oscillator type"));
  957.                             break;
  958.                         case eOscillatorSampled:
  959.                             if (!ResolveSamplesInSampleList(OscillatorGetSampleIntervalList(
  960.                                 Oscillator),SampleList,AlgoSampList))
  961.                                 {
  962.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  963.                                     return eBuildInstrSomeSamplesDontExist;
  964.                                 }
  965.                             break;
  966.                         case eOscillatorWaveTable:
  967.                             if (!ResolveWaveTablesInSampleList(OscillatorGetSampleIntervalList(
  968.                                 Oscillator),WaveTableList,AlgoWaveTableList))
  969.                                 {
  970.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  971.                                     return eBuildInstrSomeWaveTablesDontExist;
  972.                                 }
  973.                             break;
  974.                     }
  975.  
  976.                 /* eat the close paren */
  977.                 Token = GetNextToken(Scanner);
  978.                 if (Token == NIL)
  979.                     {
  980.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  981.                         return eBuildInstrOutOfMemory;
  982.                     }
  983.                 if (GetTokenType(Token) != eTokenCloseParen)
  984.                     {
  985.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  986.                         return eBuildInstrExpectedCloseParen;
  987.                     }
  988.  
  989.                 *RequiredDefinitions |= INSTRLIST_REQUIRED_OSCILLATOR;
  990.             }
  991.         else if (GetTokenKeywordTag(Token) == eKeywordTrackeffect)
  992.             {
  993.                 Error = ParseTrackEffect(GetInstrumentEffectSpecList(Instrument),
  994.                     Scanner,ErrorLine,WaveTableList,AlgoWaveTableList);
  995.                 if (Error != eBuildInstrNoError)
  996.                     {
  997.                         return Error;
  998.                     }
  999.             }
  1000.         else
  1001.             {
  1002.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1003.                 return eBuildInstrExpectedInstrumentMember;
  1004.             }
  1005.  
  1006.         return eBuildInstrNoError;
  1007.     }
  1008.  
  1009.  
  1010.  
  1011.  
  1012. /*   80:   <number>                ::= <integertoken> */
  1013. /*   81:                           ::= <floattoken> */
  1014. /* FIRST SET: */
  1015. /*  <number>                : {<integertoken>, <floattoken>} */
  1016. /* FOLLOW SET: */
  1017. /*  <number>                : {<integertoken>, <floattoken>, ), ;, type, */
  1018. /*       exponential, linear, to, sustainpoint, ampaccent1, ampaccent2, */
  1019. /*       ampaccent3, ampaccent4, ampfreq, rateaccent1, rateaccent2, rateaccent3, */
  1020. /*       rateaccent4, ratefreq, originadjust, <number>, <env_point_list>, */
  1021. /*       <env_point_elem>, <env_attributes>, <env_one_attribute>} */
  1022. static BuildInstrErrors            ParseNumber(ScannerRec* Scanner, long* ErrorLine,
  1023.                                                             double* NumberOut)
  1024.     {
  1025.         TokenRec*                                    Token;
  1026.         MyBoolean                                    Negative;
  1027.  
  1028.         CheckPtrExistence(Scanner);
  1029.  
  1030.         Negative = False;
  1031.  
  1032.      GetAnotherToken:
  1033.         Token = GetNextToken(Scanner);
  1034.         if (Token == NIL)
  1035.             {
  1036.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1037.                 return eBuildInstrOutOfMemory;
  1038.             }
  1039.  
  1040.         switch (GetTokenType(Token))
  1041.             {
  1042.                 default:
  1043.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  1044.                     return eBuildInstrExpectedNumber;
  1045.                 case eTokenInteger:
  1046.                     *NumberOut = GetTokenIntegerValue(Token);
  1047.                     break;
  1048.                 case eTokenSingle:
  1049.                     *NumberOut = GetTokenSingleValue(Token);
  1050.                     break;
  1051.                 case eTokenDouble:
  1052.                     *NumberOut = GetTokenDoubleValue(Token);
  1053.                     break;
  1054.                 case eTokenFixed:
  1055.                     *NumberOut = largefixed2double(GetTokenFixedValue(Token));
  1056.                     break;
  1057.                 case eTokenMinus:
  1058.                     Negative = !Negative;
  1059.                     goto GetAnotherToken;
  1060.             }
  1061.  
  1062.         if (Negative)
  1063.             {
  1064.                 *NumberOut = - *NumberOut;
  1065.             }
  1066.  
  1067.         return eBuildInstrNoError;
  1068.     }
  1069.  
  1070.  
  1071.  
  1072.  
  1073. /*    7:   <lfo_definition>        ::= <lfo_elem> ; <lfo_definition> */
  1074. /*    8:                           ::=  */
  1075. /* FIRST SET: */
  1076. /*  <lfo_definition>        : {oscillator, freqenvelope, modulation, */
  1077. /*       ampenvelope, <lfo_elem>} */
  1078. /* FOLLOW SET: */
  1079. /*  <lfo_definition>        : {)} */
  1080. static BuildInstrErrors            ParseLfoDefinition(LFOSpecRec* LFO, ScannerRec* Scanner,
  1081.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  1082.                                                             unsigned long OnceOnlyDefinitions,
  1083.                                                             struct WaveTableListRec* WaveTableList,
  1084.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  1085.     {
  1086.         TokenRec*                                    Token;
  1087.         BuildInstrErrors                    Error;
  1088.  
  1089.         CheckPtrExistence(LFO);
  1090.         CheckPtrExistence(Scanner);
  1091.  
  1092.         Token = GetNextToken(Scanner);
  1093.         if (Token == NIL)
  1094.             {
  1095.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1096.                 return eBuildInstrOutOfMemory;
  1097.             }
  1098.  
  1099.         if (GetTokenType(Token) == eTokenCloseParen)
  1100.             {
  1101.                 UngetToken(Scanner,Token);
  1102.                 return eBuildInstrNoError;
  1103.             }
  1104.          else
  1105.             {
  1106.                 UngetToken(Scanner,Token);
  1107.  
  1108.                 Error = ParseLfoElem(LFO,Scanner,ErrorLine,RequiredDefinitions,
  1109.                     &OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  1110.                 if (Error != eBuildInstrNoError)
  1111.                     {
  1112.                         return Error;
  1113.                     }
  1114.  
  1115.                 /* get semicolon */
  1116.                 Token = GetNextToken(Scanner);
  1117.                 if (Token == NIL)
  1118.                     {
  1119.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1120.                         return eBuildInstrOutOfMemory;
  1121.                     }
  1122.                 if (GetTokenType(Token) != eTokenSemicolon)
  1123.                     {
  1124.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1125.                         return eBuildInstrExpectedSemicolon;
  1126.                     }
  1127.  
  1128.                 return ParseLfoDefinition(LFO,Scanner,ErrorLine,RequiredDefinitions,
  1129.                     OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  1130.             }
  1131.  
  1132.         EXECUTE(PRERR(ForceAbort,"ParseLfoDefinition:  control reached end of function"));
  1133.     }
  1134.  
  1135.  
  1136.  
  1137.  
  1138. /* the identifier string returned from here is NOT trash-tracker allocated. */
  1139. /*   78:   <identifier>            ::= <identifiertoken> */
  1140. /*   79:                           ::= <stringtoken> */
  1141. /* FIRST SET: */
  1142. /*  <identifier>            : {<identifiertoken>, <stringtoken>} */
  1143. /* FOLLOW SET: */
  1144. /*  <identifier>            : {<integertoken>, <floattoken>, (, scale, */
  1145. /*       <number>} */
  1146. static BuildInstrErrors            ParseIdentifier(ScannerRec* Scanner, long* ErrorLine,
  1147.                                                             char** IdentifierOut)
  1148.     {
  1149.         TokenRec*                                    Token;
  1150.  
  1151.         CheckPtrExistence(Scanner);
  1152.  
  1153.         Token = GetNextToken(Scanner);
  1154.         if (Token == NIL)
  1155.             {
  1156.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1157.                 return eBuildInstrOutOfMemory;
  1158.             }
  1159.  
  1160.         if (GetTokenType(Token) == eTokenIdentifier)
  1161.             {
  1162.                 *IdentifierOut = CopyPtr(GetTokenIdentifierString(Token));
  1163.             }
  1164.         else if (GetTokenType(Token) == eTokenString)
  1165.             {
  1166.                 *IdentifierOut = CopyPtr(GetTokenStringValue(Token));
  1167.             }
  1168.         else
  1169.             {
  1170.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1171.                 return eBuildInstrExpectedStringOrIdentifier;
  1172.             }
  1173.  
  1174.         if (*IdentifierOut == NIL)
  1175.             {
  1176.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1177.                 return eBuildInstrOutOfMemory;
  1178.             }
  1179.         SetTag(*IdentifierOut,"BuildInstr: ParseIdentifier");
  1180.  
  1181.         return eBuildInstrNoError;
  1182.     }
  1183.  
  1184.  
  1185.  
  1186.  
  1187. /*   27:   <oscillator_definition> ::= <oscillator_elem> ; */
  1188. /*       <oscillator_definition> */
  1189. /*   28:                           ::=  */
  1190. /* FIRST SET: */
  1191. /*  <oscillator_definition> : {loudness, type, samplelist, */
  1192. /*       freqmultiplier, freqdivisor, loudnessenvelope, */
  1193. /*       loudnesslfo, indexenvelope, indexlfo, <oscillator_elem>} */
  1194. /* FOLLOW SET: */
  1195. /*  <oscillator_definition> : {)} */
  1196. static BuildInstrErrors            ParseOscillatorDefinition(OscillatorRec* Oscillator,
  1197.                                                             ScannerRec* Scanner, long* ErrorLine,
  1198.                                                             unsigned long* RequiredDefinitions,
  1199.                                                             unsigned long OnceOnlyDefinitions,
  1200.                                                             struct WaveTableListRec* WaveTableList,
  1201.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  1202.     {
  1203.         TokenRec*                                    Token;
  1204.         BuildInstrErrors                    Error;
  1205.  
  1206.         CheckPtrExistence(Oscillator);
  1207.         CheckPtrExistence(Scanner);
  1208.  
  1209.         Token = GetNextToken(Scanner);
  1210.         if (Token == NIL)
  1211.             {
  1212.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1213.                 return eBuildInstrOutOfMemory;
  1214.             }
  1215.  
  1216.         if (GetTokenType(Token) == eTokenCloseParen)
  1217.             {
  1218.                 UngetToken(Scanner,Token);
  1219.                 return eBuildInstrNoError;
  1220.             }
  1221.          else
  1222.             {
  1223.                 UngetToken(Scanner,Token);
  1224.  
  1225.                 Error = ParseOscillatorElem(Oscillator,Scanner,ErrorLine,RequiredDefinitions,
  1226.                     &OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  1227.                 if (Error != eBuildInstrNoError)
  1228.                     {
  1229.                         return Error;
  1230.                     }
  1231.  
  1232.                 /* get semicolon */
  1233.                 Token = GetNextToken(Scanner);
  1234.                 if (Token == NIL)
  1235.                     {
  1236.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1237.                         return eBuildInstrOutOfMemory;
  1238.                     }
  1239.                 if (GetTokenType(Token) != eTokenSemicolon)
  1240.                     {
  1241.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1242.                         return eBuildInstrExpectedSemicolon;
  1243.                     }
  1244.  
  1245.                 return ParseOscillatorDefinition(Oscillator,Scanner,ErrorLine,
  1246.                     RequiredDefinitions,OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  1247.             }
  1248.  
  1249.         EXECUTE(PRERR(ForceAbort,"ParseOscillatorDefinition:  control reached end of function"));
  1250.     }
  1251.  
  1252.  
  1253.  
  1254.  
  1255. /*    9:   <lfo_elem>              ::= freqenvelope ( <envelope_definition> ) */
  1256. /*   10:                           ::= ampenvelope ( <envelope_definition> ) */
  1257. /*   11:                           ::= oscillator <oscillator_type> */
  1258. /*   12:                           ::= modulation <modulation_type> */
  1259. /* FIRST SET: */
  1260. /*  <lfo_elem>              : {oscillator, freqenvelope, modulation, ampenvelope} */
  1261. /* FOLLOW SET: */
  1262. /*  <lfo_elem>              : {;} */
  1263. static BuildInstrErrors            ParseLfoElem(LFOSpecRec* LFO, ScannerRec* Scanner,
  1264.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  1265.                                                             unsigned long* OnceOnlyDefinitions,
  1266.                                                             struct WaveTableListRec* WaveTableList,
  1267.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  1268.     {
  1269.         TokenRec*                                    Token;
  1270.         BuildInstrErrors                    Error;
  1271.         unsigned long                            Required;
  1272.  
  1273.         CheckPtrExistence(LFO);
  1274.         CheckPtrExistence(Scanner);
  1275.  
  1276.         Token = GetNextToken(Scanner);
  1277.         if (Token == NIL)
  1278.             {
  1279.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1280.                 return eBuildInstrOutOfMemory;
  1281.             }
  1282.         if (GetTokenType(Token) != eTokenKeyword)
  1283.             {
  1284.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1285.                 return eBuildInstrExpectedLFOMember;
  1286.             }
  1287.  
  1288.         switch (GetTokenKeywordTag(Token))
  1289.             {
  1290.                 default:
  1291.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  1292.                     return eBuildInstrExpectedLFOMember;
  1293.  
  1294.                 case eKeywordFreqenvelope:
  1295.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_FREQENVELOPE) != 0)
  1296.                         {
  1297.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1298.                             return eBuildInstrMultipleLFOFreqEnvelope;
  1299.                         }
  1300.  
  1301.                     /* open paren */
  1302.                     Token = GetNextToken(Scanner);
  1303.                     if (Token == NIL)
  1304.                         {
  1305.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1306.                             return eBuildInstrOutOfMemory;
  1307.                         }
  1308.                     if (GetTokenType(Token) != eTokenOpenParen)
  1309.                         {
  1310.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1311.                             return eBuildInstrExpectedOpenParen;
  1312.                         }
  1313.  
  1314.                     Required = 0;
  1315.                     Error = ParseEnvelopeDefinition(GetLFOSpecFrequencyEnvelope(LFO),
  1316.                         Scanner,ErrorLine,&Required,0);
  1317.                     if (Error != eBuildInstrNoError)
  1318.                         {
  1319.                             return Error;
  1320.                         }
  1321.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1322.                         {
  1323.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1324.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1325.                         }
  1326.  
  1327.                     /* close paren */
  1328.                     Token = GetNextToken(Scanner);
  1329.                     if (Token == NIL)
  1330.                         {
  1331.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1332.                             return eBuildInstrOutOfMemory;
  1333.                         }
  1334.                     if (GetTokenType(Token) != eTokenCloseParen)
  1335.                         {
  1336.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1337.                             return eBuildInstrExpectedCloseParen;
  1338.                         }
  1339.  
  1340.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_FREQENVELOPE;
  1341.                     break;
  1342.  
  1343.                 case eKeywordAmpenvelope:
  1344.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_AMPENVELOPE) != 0)
  1345.                         {
  1346.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1347.                             return eBuildInstrMultipleLFOAmpEnvelope;
  1348.                         }
  1349.  
  1350.                     /* open paren */
  1351.                     Token = GetNextToken(Scanner);
  1352.                     if (Token == NIL)
  1353.                         {
  1354.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1355.                             return eBuildInstrOutOfMemory;
  1356.                         }
  1357.                     if (GetTokenType(Token) != eTokenOpenParen)
  1358.                         {
  1359.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1360.                             return eBuildInstrExpectedOpenParen;
  1361.                         }
  1362.  
  1363.                     Required = 0;
  1364.                     Error = ParseEnvelopeDefinition(GetLFOSpecAmplitudeEnvelope(LFO),
  1365.                         Scanner,ErrorLine,&Required,0);
  1366.                     if (Error != eBuildInstrNoError)
  1367.                         {
  1368.                             return Error;
  1369.                         }
  1370.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1371.                         {
  1372.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1373.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1374.                         }
  1375.  
  1376.                     /* close paren */
  1377.                     Token = GetNextToken(Scanner);
  1378.                     if (Token == NIL)
  1379.                         {
  1380.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1381.                             return eBuildInstrOutOfMemory;
  1382.                         }
  1383.                     if (GetTokenType(Token) != eTokenCloseParen)
  1384.                         {
  1385.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1386.                             return eBuildInstrExpectedCloseParen;
  1387.                         }
  1388.  
  1389.                     *RequiredDefinitions |= LFODEFINITION_REQUIRED_AMPENVELOPE;
  1390.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_AMPENVELOPE;
  1391.                     break;
  1392.  
  1393.                 case eKeywordOscillator:
  1394.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_OSCILLATORTYPE) != 0)
  1395.                         {
  1396.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1397.                             return eBuildInstrMultipleLFOOscillatorType;
  1398.                         }
  1399.  
  1400.                     /*  13:   <oscillator_type>       ::= constant */
  1401.                     /*  14:                           ::= signsine */
  1402.                     /*  15:                           ::= plussine */
  1403.                     /*  16:                           ::= signtriangle */
  1404.                     /*  17:                           ::= plustriangle */
  1405.                     /*  18:                           ::= signsquare <number> */
  1406.                     /*  19:                           ::= plussquare <number> */
  1407.                     /*  20:                           ::= signramp <number> */
  1408.                     /*  21:                           ::= plusramp <number> */
  1409.                     /*  22:                           ::= signlinfuzz <number> <seed> (square | triangle) */
  1410.                     /*  23:                           ::= pluslinfuzz <number> <seed> (square | triangle) */
  1411.                     /*  XX:                           ::= wavetable ( <samplelist_definition> */
  1412.                     /*                                    ) ( <envelope_definition> ) */
  1413.                     Token = GetNextToken(Scanner);
  1414.                     if (Token == NIL)
  1415.                         {
  1416.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1417.                             return eBuildInstrOutOfMemory;
  1418.                         }
  1419.                     if (GetTokenType(Token) != eTokenKeyword)
  1420.                         {
  1421.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1422.                             return eBuildInstrExpectedLFOOscillatorType;
  1423.                         }
  1424.                     switch (GetTokenKeywordTag(Token))
  1425.                         {
  1426.                             default:
  1427.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1428.                                 return eBuildInstrExpectedLFOOscillatorType;
  1429.  
  1430.                             case eKeywordConstant:
  1431.                                 SetLFOSpecOscillatorType(LFO,eLFOConstant1);
  1432.                                 break;
  1433.  
  1434.                             case eKeywordSignsine:
  1435.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedSine);
  1436.                                 break;
  1437.  
  1438.                             case eKeywordPlussine:
  1439.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveSine);
  1440.                                 break;
  1441.  
  1442.                             case eKeywordSigntriangle:
  1443.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedTriangle);
  1444.                                 break;
  1445.  
  1446.                             case eKeywordPlustriangle:
  1447.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveTriangle);
  1448.                                 break;
  1449.  
  1450.                             case eKeywordSignsquare:
  1451.                                 {
  1452.                                     double                    Number;
  1453.  
  1454.                                     SetLFOSpecOscillatorType(LFO,eLFOSignedSquare);
  1455.  
  1456.                                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1457.                                     if (Error != eBuildInstrNoError)
  1458.                                         {
  1459.                                             return Error;
  1460.                                         }
  1461.                                     SetLFOSpecExtraValue(LFO,Number);
  1462.                                 }
  1463.                                 break;
  1464.  
  1465.                             case eKeywordPlussquare:
  1466.                                 {
  1467.                                     double                    Number;
  1468.  
  1469.                                     SetLFOSpecOscillatorType(LFO,eLFOPositiveSquare);
  1470.  
  1471.                                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1472.                                     if (Error != eBuildInstrNoError)
  1473.                                         {
  1474.                                             return Error;
  1475.                                         }
  1476.                                     SetLFOSpecExtraValue(LFO,Number);
  1477.                                 }
  1478.                                 break;
  1479.  
  1480.                             case eKeywordSignramp:
  1481.                                 {
  1482.                                     double                    Number;
  1483.  
  1484.                                     SetLFOSpecOscillatorType(LFO,eLFOSignedRamp);
  1485.  
  1486.                                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1487.                                     if (Error != eBuildInstrNoError)
  1488.                                         {
  1489.                                             return Error;
  1490.                                         }
  1491.                                     SetLFOSpecExtraValue(LFO,Number);
  1492.                                 }
  1493.                                 break;
  1494.  
  1495.                             case eKeywordPlusramp:
  1496.                                 {
  1497.                                     double                    Number;
  1498.  
  1499.                                     SetLFOSpecOscillatorType(LFO,eLFOPositiveRamp);
  1500.  
  1501.                                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1502.                                     if (Error != eBuildInstrNoError)
  1503.                                         {
  1504.                                             return Error;
  1505.                                         }
  1506.                                     SetLFOSpecExtraValue(LFO,Number);
  1507.                                 }
  1508.                                 break;
  1509.  
  1510.                             case eKeywordSignlinfuzz:
  1511.                                 {
  1512.                                     double                    Seed;
  1513.  
  1514.                                     Error = ParseNumber(Scanner,ErrorLine,&Seed);
  1515.                                     if (Error != eBuildInstrNoError)
  1516.                                         {
  1517.                                             return Error;
  1518.                                         }
  1519.  
  1520.                                     Token = GetNextToken(Scanner);
  1521.                                     if (Token == NIL)
  1522.                                         {
  1523.                                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1524.                                             return eBuildInstrOutOfMemory;
  1525.                                         }
  1526.                                     if (GetTokenType(Token) != eTokenKeyword)
  1527.                                         {
  1528.                                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1529.                                             return eBuildInstrExpectedSquareOrTriangle;
  1530.                                         }
  1531.  
  1532.                                     switch (GetTokenKeywordTag(Token))
  1533.                                         {
  1534.                                             default:
  1535.                                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1536.                                                 return eBuildInstrExpectedSquareOrTriangle;
  1537.                                             case eKeywordSquare:
  1538.                                                 SetLFOSpecOscillatorType(LFO,eLFOSignedLinearFuzzSquare);
  1539.                                                 break;
  1540.                                             case eKeywordTriangle:
  1541.                                                 SetLFOSpecOscillatorType(LFO,eLFOSignedLinearFuzzTriangle);
  1542.                                                 break;
  1543.                                         }
  1544.                                     SetLFOSpecExtraValue(LFO,Seed);
  1545.                                 }
  1546.                                 break;
  1547.  
  1548.                             case eKeywordPluslinfuzz:
  1549.                                 {
  1550.                                     double                    Seed;
  1551.  
  1552.                                     Error = ParseNumber(Scanner,ErrorLine,&Seed);
  1553.                                     if (Error != eBuildInstrNoError)
  1554.                                         {
  1555.                                             return Error;
  1556.                                         }
  1557.  
  1558.                                     Token = GetNextToken(Scanner);
  1559.                                     if (Token == NIL)
  1560.                                         {
  1561.                                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1562.                                             return eBuildInstrOutOfMemory;
  1563.                                         }
  1564.                                     if (GetTokenType(Token) != eTokenKeyword)
  1565.                                         {
  1566.                                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1567.                                             return eBuildInstrExpectedSquareOrTriangle;
  1568.                                         }
  1569.  
  1570.                                     switch (GetTokenKeywordTag(Token))
  1571.                                         {
  1572.                                             default:
  1573.                                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1574.                                                 return eBuildInstrExpectedSquareOrTriangle;
  1575.                                             case eKeywordSquare:
  1576.                                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveLinearFuzzSquare);
  1577.                                                 break;
  1578.                                             case eKeywordTriangle:
  1579.                                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveLinearFuzzTriangle);
  1580.                                                 break;
  1581.                                         }
  1582.                                     SetLFOSpecExtraValue(LFO,Seed);
  1583.                                 }
  1584.                                 break;
  1585.  
  1586.                             case eKeywordWavetable:
  1587.                                 SetLFOSpecOscillatorType(LFO,eLFOWaveTable);
  1588.  
  1589.                                 /* samplelist keyword */
  1590.                                 Token = GetNextToken(Scanner);
  1591.                                 if (Token == NIL)
  1592.                                     {
  1593.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1594.                                         return eBuildInstrOutOfMemory;
  1595.                                     }
  1596.                                 if ((GetTokenType(Token) != eTokenKeyword)
  1597.                                     || (GetTokenKeywordTag(Token) != eKeywordSamplelist))
  1598.                                     {
  1599.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1600.                                         return eBuildInstrExpectedSamplelist;
  1601.                                     }
  1602.  
  1603.                                 /* open paren */
  1604.                                 Token = GetNextToken(Scanner);
  1605.                                 if (Token == NIL)
  1606.                                     {
  1607.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1608.                                         return eBuildInstrOutOfMemory;
  1609.                                     }
  1610.                                 if (GetTokenType(Token) != eTokenOpenParen)
  1611.                                     {
  1612.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1613.                                         return eBuildInstrExpectedOpenParen;
  1614.                                     }
  1615.  
  1616.                                 Error = ParseSamplelistDefinition(GetLFOSpecSampleSelector(LFO),
  1617.                                     Scanner,ErrorLine);
  1618.                                 if (Error != eBuildInstrNoError)
  1619.                                     {
  1620.                                         return Error;
  1621.                                     }
  1622.                                 if (!ResolveWaveTablesInSampleList(GetLFOSpecSampleSelector(LFO),
  1623.                                     WaveTableList,AlgoWaveTableList))
  1624.                                     {
  1625.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1626.                                         return eBuildInstrSomeWaveTablesDontExist;
  1627.                                     }
  1628.  
  1629.                                 /* close paren */
  1630.                                 Token = GetNextToken(Scanner);
  1631.                                 if (Token == NIL)
  1632.                                     {
  1633.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1634.                                         return eBuildInstrOutOfMemory;
  1635.                                     }
  1636.                                 if (GetTokenType(Token) != eTokenCloseParen)
  1637.                                     {
  1638.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1639.                                         return eBuildInstrExpectedCloseParen;
  1640.                                     }
  1641.  
  1642.                                 /* envelope keyword */
  1643.                                 Token = GetNextToken(Scanner);
  1644.                                 if (Token == NIL)
  1645.                                     {
  1646.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1647.                                         return eBuildInstrOutOfMemory;
  1648.                                     }
  1649.                                 if ((GetTokenType(Token) != eTokenKeyword)
  1650.                                     || (GetTokenKeywordTag(Token) != eKeywordEnvelope))
  1651.                                     {
  1652.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1653.                                         return eBuildInstrExpectedEnvelope;
  1654.                                     }
  1655.  
  1656.                                 /* open paren */
  1657.                                 Token = GetNextToken(Scanner);
  1658.                                 if (Token == NIL)
  1659.                                     {
  1660.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1661.                                         return eBuildInstrOutOfMemory;
  1662.                                     }
  1663.                                 if (GetTokenType(Token) != eTokenOpenParen)
  1664.                                     {
  1665.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1666.                                         return eBuildInstrExpectedOpenParen;
  1667.                                     }
  1668.  
  1669.                                 Required = 0;
  1670.                                 Error = ParseEnvelopeDefinition(GetLFOSpecWaveTableIndexEnvelope(LFO),
  1671.                                     Scanner,ErrorLine,&Required,0);
  1672.                                 if (Error != eBuildInstrNoError)
  1673.                                     {
  1674.                                         return Error;
  1675.                                     }
  1676.                                 if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1677.                                     {
  1678.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1679.                                         return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1680.                                     }
  1681.  
  1682.                                 /* close paren */
  1683.                                 Token = GetNextToken(Scanner);
  1684.                                 if (Token == NIL)
  1685.                                     {
  1686.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1687.                                         return eBuildInstrOutOfMemory;
  1688.                                     }
  1689.                                 if (GetTokenType(Token) != eTokenCloseParen)
  1690.                                     {
  1691.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1692.                                         return eBuildInstrExpectedCloseParen;
  1693.                                     }
  1694.                                 break;
  1695.                         }
  1696.  
  1697.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_OSCILLATORTYPE;
  1698.                     break;
  1699.  
  1700.                 case eKeywordModulation:
  1701.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_MODULATIONTYPE) != 0)
  1702.                         {
  1703.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1704.                             return eBuildInstrMultipleLFOModulationType;
  1705.                         }
  1706.  
  1707.                     /*  24:   <modulation_type>       ::= additive */
  1708.                     /*  25:                           ::= multiplicative */
  1709.                     /*  26:                           ::= inversemult */
  1710.                     Token = GetNextToken(Scanner);
  1711.                     if (Token == NIL)
  1712.                         {
  1713.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1714.                             return eBuildInstrOutOfMemory;
  1715.                         }
  1716.                     if (GetTokenType(Token) != eTokenKeyword)
  1717.                         {
  1718.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1719.                             return eBuildInstrExpectedLFOModulationType;
  1720.                         }
  1721.                     switch (GetTokenKeywordTag(Token))
  1722.                         {
  1723.                             default:
  1724.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1725.                                 return eBuildInstrExpectedLFOModulationType;
  1726.                             case eKeywordAdditive:
  1727.                                 SetLFOSpecModulationMode(LFO,eLFOAdditive);
  1728.                                 break;
  1729.                             case eKeywordMultiplicative:
  1730.                                 SetLFOSpecModulationMode(LFO,eLFOMultiplicative);
  1731.                                 break;
  1732.                             case eKeywordInversemult:
  1733.                                 SetLFOSpecModulationMode(LFO,eLFOInverseMultiplicative);
  1734.                                 break;
  1735.                         }
  1736.  
  1737.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_MODULATIONTYPE;
  1738.                     break;
  1739.  
  1740.                 case eKeywordHalfsteps:
  1741.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_ADDINGMODE) != 0)
  1742.                         {
  1743.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1744.                             return eBuildInstrMultipleLFOAddingMode;
  1745.                         }
  1746.  
  1747.                     SetLFOSpecAddingMode(LFO,eLFOHalfSteps);
  1748.  
  1749.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_ADDINGMODE;
  1750.                     break;
  1751.  
  1752.                 case eKeywordLinear:
  1753.                 case eKeywordHertz:
  1754.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_ADDINGMODE) != 0)
  1755.                         {
  1756.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1757.                             return eBuildInstrMultipleLFOAddingMode;
  1758.                         }
  1759.  
  1760.                     SetLFOSpecAddingMode(LFO,eLFOArithmetic);
  1761.  
  1762.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_ADDINGMODE;
  1763.                     break;
  1764.  
  1765.                 case eKeywordExponential:
  1766.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_ADDINGMODE) != 0)
  1767.                         {
  1768.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1769.                             return eBuildInstrMultipleLFOAddingMode;
  1770.                         }
  1771.  
  1772.                     SetLFOSpecAddingMode(LFO,eLFOGeometric);
  1773.  
  1774.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_ADDINGMODE;
  1775.                     break;
  1776.             }
  1777.  
  1778.         return eBuildInstrNoError;
  1779.     }
  1780.  
  1781.  
  1782.  
  1783.  
  1784. /*   29:   <oscillator_elem>       ::= type <oscillator_type> */
  1785. /*   30:                           ::= samplelist ( <samplelist_definition> ) */
  1786. /*   32:                           ::= loudness <number> */
  1787. /*   33:                           ::= freqmultiplier <number> */
  1788. /*   34:                           ::= freqdivisor <integer> */
  1789. /*   36:                           ::= loudnessenvelope ( <envelope_definition> ) */
  1790. /*   37:                           ::= loudnesslfo ( <lfo_definition> ) */
  1791. /*   38:                           ::= indexenvelope ( <envelope_definition> ) */
  1792. /*   39:                           ::= indexlfo ( <lfo_definition> ) */
  1793. /*   XXX:                          ::= stereobias <number> */
  1794. /*   XXX:                          ::= displacement <number> */
  1795. /*   XXX:                          ::= frequencylfo ( <lfo_definition> ) */
  1796. /*   XXX:                          ::= effect <oscillator_effect> */
  1797. /* FIRST SET: */
  1798. /*  <oscillator_elem>       : {loudness, type, samplelist, */
  1799. /*       freqmultiplier, freqdivisor, loudnessenvelope, */
  1800. /*       loudnesslfo, indexenvelope, indexlfo} */
  1801. /* FOLLOW SET: */
  1802. /*  <oscillator_elem>       : {;} */
  1803. static BuildInstrErrors            ParseOscillatorElem(OscillatorRec* Oscillator,
  1804.                                                             ScannerRec* Scanner, long* ErrorLine,
  1805.                                                             unsigned long* RequiredDefinitions,
  1806.                                                             unsigned long* OnceOnlyDefinitions,
  1807.                                                             struct WaveTableListRec* WaveTableList,
  1808.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  1809.     {
  1810.         TokenRec*                                    Token;
  1811.         BuildInstrErrors                    Error;
  1812.         double                                        Number;
  1813.         unsigned long                            Required;
  1814.  
  1815.         CheckPtrExistence(Oscillator);
  1816.         CheckPtrExistence(Scanner);
  1817.  
  1818.         Token = GetNextToken(Scanner);
  1819.         if (Token == NIL)
  1820.             {
  1821.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1822.                 return eBuildInstrOutOfMemory;
  1823.             }
  1824.         if (GetTokenType(Token) != eTokenKeyword)
  1825.             {
  1826.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1827.                 return eBuildInstrExpectedOscillatorMember;
  1828.             }
  1829.  
  1830.         switch (GetTokenKeywordTag(Token))
  1831.             {
  1832.                 default:
  1833.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  1834.                     return eBuildInstrExpectedOscillatorMember;
  1835.  
  1836.                 case eKeywordType:
  1837.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_TYPE) != 0)
  1838.                         {
  1839.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1840.                             return eBuildInstrMultipleOscType;
  1841.                         }
  1842.  
  1843.                     /*  40:   <oscillator_type>       ::= sampled */
  1844.                     /*  41:                           ::= wavetable */
  1845.                     Token = GetNextToken(Scanner);
  1846.                     if (Token == NIL)
  1847.                         {
  1848.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1849.                             return eBuildInstrOutOfMemory;
  1850.                         }
  1851.                     if (GetTokenType(Token) != eTokenKeyword)
  1852.                         {
  1853.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1854.                             return eBuildInstrExpectedOscType;
  1855.                         }
  1856.                     switch (GetTokenKeywordTag(Token))
  1857.                         {
  1858.                             default:
  1859.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1860.                                 return eBuildInstrExpectedOscType;
  1861.                             case eKeywordSampled:
  1862.                                 OscillatorSetTheType(Oscillator,eOscillatorSampled);
  1863.                                 break;
  1864.                             case eKeywordWavetable:
  1865.                                 OscillatorSetTheType(Oscillator,eOscillatorWaveTable);
  1866.                                 break;
  1867.                         }
  1868.  
  1869.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_TYPE;
  1870.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_TYPE;
  1871.                     break;
  1872.  
  1873.                 case eKeywordSamplelist:
  1874.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_SAMPLELIST) != 0)
  1875.                         {
  1876.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1877.                             return eBuildInstrMultipleOscSampleList;
  1878.                         }
  1879.  
  1880.                     /* open paren */
  1881.                     Token = GetNextToken(Scanner);
  1882.                     if (Token == NIL)
  1883.                         {
  1884.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1885.                             return eBuildInstrOutOfMemory;
  1886.                         }
  1887.                     if (GetTokenType(Token) != eTokenOpenParen)
  1888.                         {
  1889.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1890.                             return eBuildInstrExpectedOpenParen;
  1891.                         }
  1892.  
  1893.                     Error = ParseSamplelistDefinition(OscillatorGetSampleIntervalList(Oscillator),
  1894.                         Scanner,ErrorLine);
  1895.                     if (Error != eBuildInstrNoError)
  1896.                         {
  1897.                             return Error;
  1898.                         }
  1899.  
  1900.                     /* close paren */
  1901.                     Token = GetNextToken(Scanner);
  1902.                     if (Token == NIL)
  1903.                         {
  1904.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1905.                             return eBuildInstrOutOfMemory;
  1906.                         }
  1907.                     if (GetTokenType(Token) != eTokenCloseParen)
  1908.                         {
  1909.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1910.                             return eBuildInstrExpectedCloseParen;
  1911.                         }
  1912.  
  1913.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_SAMPLELIST;
  1914.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_SAMPLELIST;
  1915.                     break;
  1916.  
  1917.                 case eKeywordLoudness:
  1918.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_LOUDNESS) != 0)
  1919.                         {
  1920.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1921.                             return eBuildInstrMultipleOscLoudness;
  1922.                         }
  1923.  
  1924.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1925.                     if (Error != eBuildInstrNoError)
  1926.                         {
  1927.                             return Error;
  1928.                         }
  1929.                     PutOscillatorNewOutputLoudness(Oscillator,Number);
  1930.  
  1931.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_LOUDNESS;
  1932.                     break;
  1933.  
  1934.                 case eKeywordFreqmultiplier:
  1935.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_FREQMULTIPLIER) != 0)
  1936.                         {
  1937.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1938.                             return eBuildInstrMultipleOscFreqMultiplier;
  1939.                         }
  1940.  
  1941.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1942.                     if (Error != eBuildInstrNoError)
  1943.                         {
  1944.                             return Error;
  1945.                         }
  1946.                     PutOscillatorNewFrequencyFactors(Oscillator,Number,
  1947.                         OscillatorGetFrequencyDivisor(Oscillator));
  1948.  
  1949.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_FREQMULTIPLIER;
  1950.                     break;
  1951.  
  1952.                 case eKeywordFreqdivisor:
  1953.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_FREQDIVISOR) != 0)
  1954.                         {
  1955.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1956.                             return eBuildInstrMultipleOscFreqDivisor;
  1957.                         }
  1958.  
  1959.                     Token = GetNextToken(Scanner);
  1960.                     if (Token == NIL)
  1961.                         {
  1962.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1963.                             return eBuildInstrOutOfMemory;
  1964.                         }
  1965.                     if (GetTokenType(Token) != eTokenInteger)
  1966.                         {
  1967.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1968.                             return eBuildInstrExpectedInteger;
  1969.                         }
  1970.                     PutOscillatorNewFrequencyFactors(Oscillator,
  1971.                         OscillatorGetFrequencyMultiplier(Oscillator),GetTokenIntegerValue(Token));
  1972.  
  1973.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_FREQDIVISOR;
  1974.                     break;
  1975.  
  1976.                 case eKeywordFreqadder:
  1977.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_FREQADDER) != 0)
  1978.                         {
  1979.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1980.                             return eBuildInstrMultipleOscFreqAdder;
  1981.                         }
  1982.  
  1983.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1984.                     if (Error != eBuildInstrNoError)
  1985.                         {
  1986.                             return Error;
  1987.                         }
  1988.                     PutOscillatorFrequencyAdder(Oscillator,Number);
  1989.  
  1990.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_FREQADDER;
  1991.                     break;
  1992.  
  1993.                 case eKeywordLoudnessenvelope:
  1994.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_LOUDNESSENVELOPE) != 0)
  1995.                         {
  1996.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1997.                             return eBuildInstrMultipleOscLoudnessEnvelope;
  1998.                         }
  1999.  
  2000.                     /* open paren */
  2001.                     Token = GetNextToken(Scanner);
  2002.                     if (Token == NIL)
  2003.                         {
  2004.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2005.                             return eBuildInstrOutOfMemory;
  2006.                         }
  2007.                     if (GetTokenType(Token) != eTokenOpenParen)
  2008.                         {
  2009.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2010.                             return eBuildInstrExpectedOpenParen;
  2011.                         }
  2012.  
  2013.                     Required = 0;
  2014.                     Error = ParseEnvelopeDefinition(OscillatorGetLoudnessEnvelope(Oscillator),
  2015.                         Scanner,ErrorLine,&Required,0);
  2016.                     if (Error != eBuildInstrNoError)
  2017.                         {
  2018.                             return Error;
  2019.                         }
  2020.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  2021.                         {
  2022.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2023.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  2024.                         }
  2025.  
  2026.                     /* close paren */
  2027.                     Token = GetNextToken(Scanner);
  2028.                     if (Token == NIL)
  2029.                         {
  2030.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2031.                             return eBuildInstrOutOfMemory;
  2032.                         }
  2033.                     if (GetTokenType(Token) != eTokenCloseParen)
  2034.                         {
  2035.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2036.                             return eBuildInstrExpectedCloseParen;
  2037.                         }
  2038.  
  2039.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_LOUDNESSENVELOPE;
  2040.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_LOUDNESSENVELOPE;
  2041.                     break;
  2042.  
  2043.                 case eKeywordLoudnesslfo:
  2044.                     {
  2045.                         LFOSpecRec*                    LFO;
  2046.  
  2047.                         /* create the LFO */
  2048.                         LFO = NewLFOSpecifier();
  2049.                         if (LFO == NIL)
  2050.                             {
  2051.                              LoudnessLFOAllocFailurePoint1:
  2052.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2053.                                 return eBuildInstrOutOfMemory;
  2054.                             }
  2055.                         if (!LFOListSpecAppendNewEntry(OscillatorGetLoudnessLFOList(Oscillator),LFO))
  2056.                             {
  2057.                              LoudnessLFOAllocFailurePoint2:
  2058.                                 DisposeLFOSpecifier(LFO);
  2059.                                 goto LoudnessLFOAllocFailurePoint1;
  2060.                             }
  2061.  
  2062.                         /* open paren */
  2063.                         Token = GetNextToken(Scanner);
  2064.                         if (Token == NIL)
  2065.                             {
  2066.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2067.                                 return eBuildInstrOutOfMemory;
  2068.                             }
  2069.                         if (GetTokenType(Token) != eTokenOpenParen)
  2070.                             {
  2071.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2072.                                 return eBuildInstrExpectedOpenParen;
  2073.                             }
  2074.  
  2075.                         Required = 0;
  2076.                         Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&Required,0,
  2077.                             WaveTableList,AlgoWaveTableList);
  2078.                         if (Error != eBuildInstrNoError)
  2079.                             {
  2080.                                 return Error;
  2081.                             }
  2082.                         if (Required != LFODEFINITION_REQUIREDMASK)
  2083.                             {
  2084.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2085.                                 return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  2086.                             }
  2087.  
  2088.                         /* close paren */
  2089.                         Token = GetNextToken(Scanner);
  2090.                         if (Token == NIL)
  2091.                             {
  2092.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2093.                                 return eBuildInstrOutOfMemory;
  2094.                             }
  2095.                         if (GetTokenType(Token) != eTokenCloseParen)
  2096.                             {
  2097.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2098.                                 return eBuildInstrExpectedCloseParen;
  2099.                             }
  2100.                     }
  2101.                     break;
  2102.  
  2103.                 case eKeywordIndexenvelope:
  2104.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_INDEXENVELOPE) != 0)
  2105.                         {
  2106.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2107.                             return eBuildInstrMultipleOscIndexEnvelope;
  2108.                         }
  2109.  
  2110.                     /* open paren */
  2111.                     Token = GetNextToken(Scanner);
  2112.                     if (Token == NIL)
  2113.                         {
  2114.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2115.                             return eBuildInstrOutOfMemory;
  2116.                         }
  2117.                     if (GetTokenType(Token) != eTokenOpenParen)
  2118.                         {
  2119.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2120.                             return eBuildInstrExpectedOpenParen;
  2121.                         }
  2122.  
  2123.                     Required = 0;
  2124.                     Error = ParseEnvelopeDefinition(OscillatorGetExcitationEnvelope(Oscillator),
  2125.                         Scanner,ErrorLine,&Required,0);
  2126.                     if (Error != eBuildInstrNoError)
  2127.                         {
  2128.                             return Error;
  2129.                         }
  2130.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  2131.                         {
  2132.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2133.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  2134.                         }
  2135.  
  2136.                     /* close paren */
  2137.                     Token = GetNextToken(Scanner);
  2138.                     if (Token == NIL)
  2139.                         {
  2140.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2141.                             return eBuildInstrOutOfMemory;
  2142.                         }
  2143.                     if (GetTokenType(Token) != eTokenCloseParen)
  2144.                         {
  2145.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2146.                             return eBuildInstrExpectedCloseParen;
  2147.                         }
  2148.  
  2149.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_INDEXENVELOPE;
  2150.                     break;
  2151.  
  2152.                 case eKeywordIndexlfo:
  2153.                     {
  2154.                         LFOSpecRec*                    LFO;
  2155.  
  2156.                         /* create the LFO */
  2157.                         LFO = NewLFOSpecifier();
  2158.                         if (LFO == NIL)
  2159.                             {
  2160.                              IndexLFOAllocFailurePoint1:
  2161.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2162.                                 return eBuildInstrOutOfMemory;
  2163.                             }
  2164.                         if (!LFOListSpecAppendNewEntry(OscillatorGetExcitationLFOList(Oscillator),LFO))
  2165.                             {
  2166.                              IndexLFOAllocFailurePoint2:
  2167.                                 DisposeLFOSpecifier(LFO);
  2168.                                 goto IndexLFOAllocFailurePoint1;
  2169.                             }
  2170.  
  2171.                         /* open paren */
  2172.                         Token = GetNextToken(Scanner);
  2173.                         if (Token == NIL)
  2174.                             {
  2175.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2176.                                 return eBuildInstrOutOfMemory;
  2177.                             }
  2178.                         if (GetTokenType(Token) != eTokenOpenParen)
  2179.                             {
  2180.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2181.                                 return eBuildInstrExpectedOpenParen;
  2182.                             }
  2183.  
  2184.                         Required = 0;
  2185.                         Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&Required,0,
  2186.                             WaveTableList,AlgoWaveTableList);
  2187.                         if (Error != eBuildInstrNoError)
  2188.                             {
  2189.                                 return Error;
  2190.                             }
  2191.                         if (Required != LFODEFINITION_REQUIREDMASK)
  2192.                             {
  2193.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2194.                                 return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  2195.                             }
  2196.  
  2197.                         /* close paren */
  2198.                         Token = GetNextToken(Scanner);
  2199.                         if (Token == NIL)
  2200.                             {
  2201.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2202.                                 return eBuildInstrOutOfMemory;
  2203.                             }
  2204.                         if (GetTokenType(Token) != eTokenCloseParen)
  2205.                             {
  2206.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2207.                                 return eBuildInstrExpectedCloseParen;
  2208.                             }
  2209.                     }
  2210.                     break;
  2211.  
  2212.                 case eKeywordStereobias:
  2213.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_STEREOBIAS) != 0)
  2214.                         {
  2215.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2216.                             return eBuildInstrMultipleOscStereoBias;
  2217.                         }
  2218.  
  2219.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2220.                     if (Error != eBuildInstrNoError)
  2221.                         {
  2222.                             return Error;
  2223.                         }
  2224.                     OscillatorPutStereoBias(Oscillator,Number);
  2225.  
  2226.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_STEREOBIAS;
  2227.                     break;
  2228.  
  2229.                 case eKeywordDisplacement:
  2230.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_TIMEDISPLACEMENT) != 0)
  2231.                         {
  2232.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2233.                             return eBuildInstrMultipleOscDisplacement;
  2234.                         }
  2235.  
  2236.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2237.                     if (Error != eBuildInstrNoError)
  2238.                         {
  2239.                             return Error;
  2240.                         }
  2241.                     OscillatorPutTimeDisplacement(Oscillator,Number);
  2242.  
  2243.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_TIMEDISPLACEMENT;
  2244.                     break;
  2245.  
  2246.                 case eKeywordSurroundbias:
  2247.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_SURROUNDBIAS) != 0)
  2248.                         {
  2249.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2250.                             return eBuildInstrMultipleOscSurroundBias;
  2251.                         }
  2252.  
  2253.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2254.                     if (Error != eBuildInstrNoError)
  2255.                         {
  2256.                             return Error;
  2257.                         }
  2258.                     OscillatorPutSurroundBias(Oscillator,Number);
  2259.  
  2260.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_SURROUNDBIAS;
  2261.                     break;
  2262.  
  2263.                 case eKeywordFrequencylfo:
  2264.                     {
  2265.                         unsigned long                            LFORequired;
  2266.                         LFOSpecRec*                                LFO;
  2267.  
  2268.                         /* allocate the LFO */
  2269.                         LFO = NewLFOSpecifier();
  2270.                         if (LFO == NIL)
  2271.                             {
  2272.                              LFOAllocFailurePoint1:
  2273.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2274.                                 return eBuildInstrOutOfMemory;
  2275.                             }
  2276.                         /* the default arithmetic mode for pitch LFO is halfsteps */
  2277.                         SetLFOSpecAddingMode(LFO,eLFOHalfSteps);
  2278.                         if (!LFOListSpecAppendNewEntry(GetOscillatorFrequencyLFOList(Oscillator),LFO))
  2279.                             {
  2280.                              LFOAllocFailurePoint2:
  2281.                                 DisposeLFOSpecifier(LFO);
  2282.                                 goto LFOAllocFailurePoint1;
  2283.                             }
  2284.  
  2285.                         /* open paren */
  2286.                         Token = GetNextToken(Scanner);
  2287.                         if (Token == NIL)
  2288.                             {
  2289.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2290.                                 return eBuildInstrOutOfMemory;
  2291.                             }
  2292.                         if (GetTokenType(Token) != eTokenOpenParen)
  2293.                             {
  2294.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2295.                                 return eBuildInstrExpectedOpenParen;
  2296.                             }
  2297.  
  2298.                         /* parse the low frequency operator */
  2299.                         LFORequired = 0;
  2300.                         Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&LFORequired,0,WaveTableList,
  2301.                             AlgoWaveTableList);
  2302.                         if (Error != eBuildInstrNoError)
  2303.                             {
  2304.                                 return Error;
  2305.                             }
  2306.                         if (LFORequired != LFODEFINITION_REQUIREDMASK)
  2307.                             {
  2308.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2309.                                 return eBuildInstrSomeRequiredLFOParamsMissing;
  2310.                             }
  2311.  
  2312.                         /* close paren */
  2313.                         Token = GetNextToken(Scanner);
  2314.                         if (Token == NIL)
  2315.                             {
  2316.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2317.                                 return eBuildInstrOutOfMemory;
  2318.                             }
  2319.                         if (GetTokenType(Token) != eTokenCloseParen)
  2320.                             {
  2321.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2322.                                 return eBuildInstrExpectedCloseParen;
  2323.                             }
  2324.                     }
  2325.                     break;
  2326.  
  2327.                 case eKeywordEffect:
  2328.                     Token = GetNextToken(Scanner);
  2329.                     if (Token == NIL)
  2330.                         {
  2331.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2332.                             return eBuildInstrOutOfMemory;
  2333.                         }
  2334.                     if (GetTokenType(Token) != eTokenKeyword)
  2335.                         {
  2336.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2337.                             return eBuildInstrExpectedOscillatorEffect;
  2338.                         }
  2339.                     switch (GetTokenType(Token))
  2340.                         {
  2341.                             default:
  2342.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2343.                                 return eBuildInstrExpectedOscillatorEffect;
  2344.                             case eKeywordAnalyzer:
  2345.                                 {
  2346.                                     char*                                        IDString;
  2347.                                     AnalyzerSpecRec*                Analyzer;
  2348.  
  2349.                                     Error = ParseIdentifier(Scanner,ErrorLine,&IDString);
  2350.                                     if (Error != eBuildInstrNoError)
  2351.                                         {
  2352.                                             return Error;
  2353.                                         }
  2354.                                     Analyzer = NewAnalyzerSpec(IDString);
  2355.                                     ReleasePtr(IDString);
  2356.                                     if (Analyzer == NIL)
  2357.                                         {
  2358.                                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2359.                                             return eBuildInstrOutOfMemory;
  2360.                                         }
  2361.                                     if (!AddAnalyzerToEffectSpecList(GetOscillatorEffectList(
  2362.                                         Oscillator),Analyzer))
  2363.                                         {
  2364.                                             DisposeAnalyzerSpec(Analyzer);
  2365.                                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2366.                                             return eBuildInstrOutOfMemory;
  2367.                                         }
  2368.                                 }
  2369.                                 break;
  2370.                         }
  2371.                     break;
  2372.             }
  2373.  
  2374.         return eBuildInstrNoError;
  2375.     }
  2376.  
  2377.  
  2378.  
  2379.  
  2380. /*   42:   <envelope_definition>   ::= <envelope_elem> ; <envelope_definition> */
  2381. /*   43:                           ::=  */
  2382. /* FIRST SET: */
  2383. /*  <envelope_definition>   : {totalscaling, points, <envelope_elem>} */
  2384. /* FOLLOW SET: */
  2385. /*  <envelope_definition>   : {)} */
  2386. static BuildInstrErrors            ParseEnvelopeDefinition(EnvelopeRec* Envelope,
  2387.                                                             ScannerRec* Scanner, long* ErrorLine,
  2388.                                                             unsigned long* RequiredDefinitions,
  2389.                                                             unsigned long OnceOnlyDefinitions)
  2390.     {
  2391.         TokenRec*                                    Token;
  2392.         BuildInstrErrors                    Error;
  2393.  
  2394.         CheckPtrExistence(Envelope);
  2395.         CheckPtrExistence(Scanner);
  2396.  
  2397.         Token = GetNextToken(Scanner);
  2398.         if (Token == NIL)
  2399.             {
  2400.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2401.                 return eBuildInstrOutOfMemory;
  2402.             }
  2403.  
  2404.         if (GetTokenType(Token) == eTokenCloseParen)
  2405.             {
  2406.                 UngetToken(Scanner,Token);
  2407.                 return eBuildInstrNoError;
  2408.             }
  2409.          else
  2410.             {
  2411.                 UngetToken(Scanner,Token);
  2412.  
  2413.                 Error = ParseEnvelopeElem(Envelope,Scanner,ErrorLine,RequiredDefinitions,
  2414.                     &OnceOnlyDefinitions);
  2415.                 if (Error != eBuildInstrNoError)
  2416.                     {
  2417.                         return Error;
  2418.                     }
  2419.  
  2420.                 /* get semicolon */
  2421.                 Token = GetNextToken(Scanner);
  2422.                 if (Token == NIL)
  2423.                     {
  2424.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2425.                         return eBuildInstrOutOfMemory;
  2426.                     }
  2427.                 if (GetTokenType(Token) != eTokenSemicolon)
  2428.                     {
  2429.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2430.                         return eBuildInstrExpectedSemicolon;
  2431.                     }
  2432.  
  2433.                 return ParseEnvelopeDefinition(Envelope,Scanner,ErrorLine,RequiredDefinitions,
  2434.                     OnceOnlyDefinitions);
  2435.             }
  2436.  
  2437.         EXECUTE(PRERR(ForceAbort,"ParseEnvelopeDefinition:  control reached end of function"));
  2438.     }
  2439.  
  2440.  
  2441.  
  2442.  
  2443. /*   68:   <samplelist_definition> ::= <samplelist_elem> ; */
  2444. /*       <samplelist_definition> */
  2445. /*   69:                           ::=  */
  2446. /* FIRST SET: */
  2447. /*  <samplelist_definition> : {<identifiertoken>, <stringtoken>, */
  2448. /*       <identifier>, <samplelist_elem>} */
  2449. /* FOLLOW SET: */
  2450. /*  <samplelist_definition> : {)} */
  2451. static BuildInstrErrors            ParseSamplelistDefinition(SampleSelectorRec* SampleList,
  2452.                                                             ScannerRec* Scanner, long* ErrorLine)
  2453.     {
  2454.         TokenRec*                                    Token;
  2455.         BuildInstrErrors                    Error;
  2456.  
  2457.         CheckPtrExistence(SampleList);
  2458.         CheckPtrExistence(Scanner);
  2459.  
  2460.         Token = GetNextToken(Scanner);
  2461.         if (Token == NIL)
  2462.             {
  2463.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2464.                 return eBuildInstrOutOfMemory;
  2465.             }
  2466.  
  2467.         if (GetTokenType(Token) == eTokenCloseParen)
  2468.             {
  2469.                 UngetToken(Scanner,Token);
  2470.                 return eBuildInstrNoError;
  2471.             }
  2472.          else
  2473.             {
  2474.                 UngetToken(Scanner,Token);
  2475.  
  2476.                 Error = ParseSamplelistElem(SampleList,Scanner,ErrorLine);
  2477.                 if (Error != eBuildInstrNoError)
  2478.                     {
  2479.                         return Error;
  2480.                     }
  2481.  
  2482.                 /* get semicolon */
  2483.                 Token = GetNextToken(Scanner);
  2484.                 if (Token == NIL)
  2485.                     {
  2486.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2487.                         return eBuildInstrOutOfMemory;
  2488.                     }
  2489.                 if (GetTokenType(Token) != eTokenSemicolon)
  2490.                     {
  2491.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2492.                         return eBuildInstrExpectedSemicolon;
  2493.                     }
  2494.  
  2495.                 return ParseSamplelistDefinition(SampleList,Scanner,ErrorLine);
  2496.             }
  2497.  
  2498.         EXECUTE(PRERR(ForceAbort,"ParseSamplelistDefinition:  control reached end of function"));
  2499.     }
  2500.  
  2501.  
  2502.  
  2503.  
  2504. /*   45:   <envelope_elem>         ::= totalscaling <number> */
  2505. /*   49:                           ::= points ( <env_point_list> ) */
  2506. /* FIRST SET: */
  2507. /*  <envelope_elem>         : {totalscaling, points} */
  2508. /* FOLLOW SET: */
  2509. /*  <envelope_elem>         : {;} */
  2510. static BuildInstrErrors            ParseEnvelopeElem(EnvelopeRec* Envelope,
  2511.                                                             ScannerRec* Scanner, long *ErrorLine,
  2512.                                                             unsigned long* RequiredDefinitions,
  2513.                                                             unsigned long* OnceOnlyDefinitions)
  2514.     {
  2515.         TokenRec*                                    Token;
  2516.         BuildInstrErrors                    Error;
  2517.         double                                        Number;
  2518.  
  2519.         CheckPtrExistence(Envelope);
  2520.         CheckPtrExistence(Scanner);
  2521.  
  2522.         Token = GetNextToken(Scanner);
  2523.         if (Token == NIL)
  2524.             {
  2525.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2526.                 return eBuildInstrOutOfMemory;
  2527.             }
  2528.         if (GetTokenType(Token) != eTokenKeyword)
  2529.             {
  2530.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2531.                 return eBuildInstrExpectedEnvelopeMember;
  2532.             }
  2533.  
  2534.         switch (GetTokenKeywordTag(Token))
  2535.             {
  2536.                 default:
  2537.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2538.                     return eBuildInstrExpectedEnvelopeMember;
  2539.  
  2540.                 case eKeywordTotalscaling:
  2541.                     if ((*OnceOnlyDefinitions & ENVELOPEDEFINITION_ONCEONLY_TOTALSCALING) != 0)
  2542.                         {
  2543.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2544.                             return eBuildInstrMultipleEnvTotalScaling;
  2545.                         }
  2546.  
  2547.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2548.                     if (Error != eBuildInstrNoError)
  2549.                         {
  2550.                             return Error;
  2551.                         }
  2552.                     EnvelopeSetOverallAmplitude(Envelope,Number);
  2553.  
  2554.                     *OnceOnlyDefinitions |= ENVELOPEDEFINITION_ONCEONLY_TOTALSCALING;
  2555.                     break;
  2556.  
  2557.                 case eKeywordPoints:
  2558.                     if ((*OnceOnlyDefinitions & ENVELOPEDEFINITION_ONCEONLY_POINTS) != 0)
  2559.                         {
  2560.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2561.                             return eBuildInstrMultipleEnvPoints;
  2562.                         }
  2563.  
  2564.                     /* open paren */
  2565.                     Token = GetNextToken(Scanner);
  2566.                     if (Token == NIL)
  2567.                         {
  2568.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2569.                             return eBuildInstrOutOfMemory;
  2570.                         }
  2571.                     if (GetTokenType(Token) != eTokenOpenParen)
  2572.                         {
  2573.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2574.                             return eBuildInstrExpectedOpenParen;
  2575.                         }
  2576.  
  2577.                     Error = ParseEnvPointList(Envelope,Scanner,ErrorLine);
  2578.                     if (Error != eBuildInstrNoError)
  2579.                         {
  2580.                             return Error;
  2581.                         }
  2582.  
  2583.                     /* close paren */
  2584.                     Token = GetNextToken(Scanner);
  2585.                     if (Token == NIL)
  2586.                         {
  2587.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2588.                             return eBuildInstrOutOfMemory;
  2589.                         }
  2590.                     if (GetTokenType(Token) != eTokenCloseParen)
  2591.                         {
  2592.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2593.                             return eBuildInstrExpectedCloseParen;
  2594.                         }
  2595.  
  2596.                     *OnceOnlyDefinitions |= ENVELOPEDEFINITION_ONCEONLY_POINTS;
  2597.                     break;
  2598.             }
  2599.  
  2600.         return eBuildInstrNoError;
  2601.     }
  2602.  
  2603.  
  2604.  
  2605.  
  2606. /*   70:   <samplelist_elem>       ::= <identifier> <number> */
  2607. /* FIRST SET: */
  2608. /*  <samplelist_elem>       : {<identifiertoken>, <stringtoken>, <identifier>} */
  2609. /* FOLLOW SET: */
  2610. /*  <samplelist_elem>       : {;} */
  2611. static BuildInstrErrors            ParseSamplelistElem(SampleSelectorRec* SampleList,
  2612.                                                             ScannerRec* Scanner, long* ErrorLine)
  2613.     {
  2614.         BuildInstrErrors                    Error;
  2615.         char*                                            SampleName;
  2616.         double                                        Number;
  2617.  
  2618.         CheckPtrExistence(SampleList);
  2619.         CheckPtrExistence(Scanner);
  2620.  
  2621.         Error = ParseIdentifier(Scanner,ErrorLine,&SampleName);
  2622.         if (Error != eBuildInstrNoError)
  2623.             {
  2624.                 return Error;
  2625.             }
  2626.  
  2627.         Error = ParseNumber(Scanner,ErrorLine,&Number);
  2628.         if (Error != eBuildInstrNoError)
  2629.             {
  2630.                 ReleasePtr(SampleName);
  2631.                 return Error;
  2632.             }
  2633.  
  2634.         if (!AppendSampleSelector(SampleList,Number,SampleName))
  2635.             {
  2636.                 ReleasePtr(SampleName);
  2637.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2638.                 return eBuildInstrOutOfMemory;
  2639.             }
  2640.  
  2641.         return eBuildInstrNoError;
  2642.     }
  2643.  
  2644.  
  2645.  
  2646.  
  2647. /*   50:   <env_point_list>        ::= <env_point_elem> ; <env_point_list> */
  2648. /*   51:                           ::=  */
  2649. /* FIRST SET: */
  2650. /*  <env_point_list>        : {<integertoken>, <floattoken>, <number>, */
  2651. /*       <env_point_elem>} */
  2652. /* FOLLOW SET: */
  2653. /*  <env_point_list>        : {)} */
  2654. static BuildInstrErrors            ParseEnvPointList(EnvelopeRec* Envelope,
  2655.                                                             ScannerRec* Scanner, long *ErrorLine)
  2656.     {
  2657.         TokenRec*                                    Token;
  2658.         BuildInstrErrors                    Error;
  2659.  
  2660.         CheckPtrExistence(Envelope);
  2661.         CheckPtrExistence(Scanner);
  2662.  
  2663.         Token = GetNextToken(Scanner);
  2664.         if (Token == NIL)
  2665.             {
  2666.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2667.                 return eBuildInstrOutOfMemory;
  2668.             }
  2669.  
  2670.         if (GetTokenType(Token) == eTokenCloseParen)
  2671.             {
  2672.                 UngetToken(Scanner,Token);
  2673.                 return eBuildInstrNoError;
  2674.             }
  2675.          else
  2676.             {
  2677.                 UngetToken(Scanner,Token);
  2678.  
  2679.                 Error = ParseEnvPointElem(Envelope,Scanner,ErrorLine);
  2680.                 if (Error != eBuildInstrNoError)
  2681.                     {
  2682.                         return Error;
  2683.                     }
  2684.  
  2685.                 /* get semicolon */
  2686.                 Token = GetNextToken(Scanner);
  2687.                 if (Token == NIL)
  2688.                     {
  2689.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2690.                         return eBuildInstrOutOfMemory;
  2691.                     }
  2692.                 if (GetTokenType(Token) != eTokenSemicolon)
  2693.                     {
  2694.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2695.                         return eBuildInstrExpectedSemicolon;
  2696.                     }
  2697.  
  2698.                 return ParseEnvPointList(Envelope,Scanner,ErrorLine);
  2699.             }
  2700.  
  2701.         EXECUTE(PRERR(ForceAbort,"ParseEnvPointList:  control reached end of function"));
  2702.     }
  2703.  
  2704.  
  2705.  
  2706.  
  2707. /*   52:   <env_point_elem>        ::= delay <number> level <number> <env_attributes> */
  2708. /*   XX:                           ::= origin */
  2709. /* FIRST SET: */
  2710. /*  <env_point_elem>        : {delay} */
  2711. /* FOLLOW SET: */
  2712. /*  <env_point_elem>        : {<integertoken>, <floattoken>, ), <number>, */
  2713. /*       <env_point_list>, <env_point_elem>} */
  2714. static BuildInstrErrors            ParseEnvPointElem(EnvelopeRec* Envelope,
  2715.                                                             ScannerRec* Scanner, long *ErrorLine)
  2716.     {
  2717.         TokenRec*                                    Token;
  2718.         BuildInstrErrors                    Error;
  2719.         double                                        Delay;
  2720.         double                                        Level;
  2721.  
  2722.         CheckPtrExistence(Envelope);
  2723.         CheckPtrExistence(Scanner);
  2724.  
  2725.         Token = GetNextToken(Scanner);
  2726.         if (Token == NIL)
  2727.             {
  2728.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2729.                 return eBuildInstrOutOfMemory;
  2730.             }
  2731.         if (GetTokenType(Token) != eTokenKeyword)
  2732.             {
  2733.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2734.                 return eBuildInstrExpectedDelayOrOrigin;
  2735.             }
  2736.  
  2737.         switch (GetTokenKeywordTag(Token))
  2738.             {
  2739.                 default:
  2740.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2741.                     return eBuildInstrExpectedDelayOrOrigin;
  2742.  
  2743.                 case eKeywordDelay:
  2744.                     Error = ParseNumber(Scanner,ErrorLine,&Delay);
  2745.                     if (Error != eBuildInstrNoError)
  2746.                         {
  2747.                             return Error;
  2748.                         }
  2749.  
  2750.                     Token = GetNextToken(Scanner);
  2751.                     if (Token == NIL)
  2752.                         {
  2753.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2754.                             return eBuildInstrOutOfMemory;
  2755.                         }
  2756.                     if ((GetTokenType(Token) != eTokenKeyword)
  2757.                         || ((GetTokenKeywordTag(Token) != eKeywordLevel)
  2758.                             && (GetTokenKeywordTag(Token) != eKeywordScale)))
  2759.                         {
  2760.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2761.                             return eBuildInstrExpectedLevelOrScale;
  2762.                         }
  2763.  
  2764.                     Error = ParseNumber(Scanner,ErrorLine,&Level);
  2765.                     if (Error != eBuildInstrNoError)
  2766.                         {
  2767.                             return Error;
  2768.                         }
  2769.  
  2770.                     if (!EnvelopeInsertPhase(Envelope,GetEnvelopeNumFrames(Envelope)))
  2771.                         {
  2772.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2773.                             return eBuildInstrOutOfMemory;
  2774.                         }
  2775.                     if (GetTokenKeywordTag(Token) == eKeywordScale)
  2776.                         {
  2777.                             EnvelopeSetPhaseTargetType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2778.                                 eEnvelopeTargetScaling);
  2779.                         }
  2780.                      else
  2781.                         {
  2782.                             EnvelopeSetPhaseTargetType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2783.                                 eEnvelopeTargetAbsolute);
  2784.                         }
  2785.                     EnvelopeSetPhaseDuration(Envelope,GetEnvelopeNumFrames(Envelope) - 1,Delay);
  2786.                     EnvelopeSetPhaseFinalValue(Envelope,GetEnvelopeNumFrames(Envelope) - 1,Level);
  2787.  
  2788.                     return ParseEnvAttributes(Envelope,Scanner,ErrorLine,0);
  2789.  
  2790.                 case eKeywordOrigin:
  2791.                     EnvelopeSetOrigin(Envelope,GetEnvelopeNumFrames(Envelope));
  2792.                     return eBuildInstrNoError;
  2793.             }
  2794.         EXECUTE(PRERR(ForceAbort,"ParseEnvPointElem:  Control reached end of function"));
  2795.     }
  2796.  
  2797.  
  2798.  
  2799.  
  2800. /*   50:   <env_attributes>        ::= <env_one_attribute> <env_attributes> */
  2801. /*   51:                           ::=  */
  2802. /* FIRST SET: */
  2803. /*  <env_attributes>        : {exponential, linear, sustainpoint, */
  2804. /*       ampaccent1, ampaccent2, ampaccent3, ampaccent4, ampfreq, rateaccent1, */
  2805. /*       rateaccent2, rateaccent3, rateaccent4, ratefreq, <env_one_attribute>} */
  2806. /* FOLLOW SET: */
  2807. /*  <env_attributes>        : {;} */
  2808. static BuildInstrErrors            ParseEnvAttributes(EnvelopeRec* Envelope,
  2809.                                                             ScannerRec* Scanner, long *ErrorLine,
  2810.                                                             unsigned long OnceOnly)
  2811.     {
  2812.         TokenRec*                                    Token;
  2813.         BuildInstrErrors                    Error;
  2814.  
  2815.         CheckPtrExistence(Envelope);
  2816.         CheckPtrExistence(Scanner);
  2817.  
  2818.         Token = GetNextToken(Scanner);
  2819.         if (Token == NIL)
  2820.             {
  2821.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2822.                 return eBuildInstrOutOfMemory;
  2823.             }
  2824.  
  2825.         if (GetTokenType(Token) == eTokenSemicolon)
  2826.             {
  2827.                 UngetToken(Scanner,Token);
  2828.                 return eBuildInstrNoError;
  2829.             }
  2830.          else
  2831.             {
  2832.                 UngetToken(Scanner,Token);
  2833.  
  2834.                 Error = ParseEnvOneAttribute(Envelope,Scanner,ErrorLine,&OnceOnly);
  2835.                 if (Error != eBuildInstrNoError)
  2836.                     {
  2837.                         return Error;
  2838.                     }
  2839.  
  2840.                 return ParseEnvAttributes(Envelope,Scanner,ErrorLine,OnceOnly);
  2841.             }
  2842.  
  2843.         EXECUTE(PRERR(ForceAbort,"ParseEnvAttributes:  control reached end of function"));
  2844.     }
  2845.  
  2846.  
  2847.  
  2848.  
  2849. /*   52:   <env_one_attribute>     ::= sustainpoint <integertoken> */
  2850. /*   53:                           ::= ampaccent1 <number> */
  2851. /*   54:                           ::= ampaccent2 <number> */
  2852. /*   55:                           ::= ampaccent3 <number> */
  2853. /*   56:                           ::= ampaccent4 <number> */
  2854. /*   57:                           ::= ampfreq <number> <number> */
  2855. /*   58:                           ::= rateaccent1 <number> */
  2856. /*   59:                           ::= rateaccent2 <number> */
  2857. /*   60:                           ::= rateaccent3 <number> */
  2858. /*   61:                           ::= rateaccent4 <number> */
  2859. /*   62:                           ::= ratefreq <number> <number> */
  2860. /*   63:                           ::= exponential */
  2861. /*   64:                           ::= linear */
  2862. /* FIRST SET: */
  2863. /*  <env_one_attribute>     : {exponential, linear, sustainpoint, */
  2864. /*       ampaccent1, ampaccent2, ampaccent3, ampaccent4, ampfreq, */
  2865. /*       rateaccent1, rateaccent2, rateaccent3, rateaccent4, ratefreq} */
  2866. /* FOLLOW SET: */
  2867. /*  <env_one_attribute>     : {;, exponential, linear, */
  2868. /*       sustainpoint, ampaccent1, ampaccent2, ampaccent3, ampaccent4, */
  2869. /*       ampfreq, rateaccent1, rateaccent2, rateaccent3, rateaccent4, */
  2870. /*       ratefreq, <env_attributes>, <env_one_attribute>} */
  2871. static BuildInstrErrors            ParseEnvOneAttribute(EnvelopeRec* Envelope,
  2872.                                                             ScannerRec* Scanner, long *ErrorLine,
  2873.                                                             unsigned long* OnceOnlyDefinitions)
  2874.     {
  2875.         TokenRec*                                    Token;
  2876.         BuildInstrErrors                    Error;
  2877.         double                                        Number;
  2878.  
  2879.         CheckPtrExistence(Envelope);
  2880.         CheckPtrExistence(Scanner);
  2881.  
  2882.         Token = GetNextToken(Scanner);
  2883.         if (Token == NIL)
  2884.             {
  2885.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2886.                 return eBuildInstrNoError;
  2887.             }
  2888.         if (GetTokenType(Token) != eTokenKeyword)
  2889.             {
  2890.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2891.                 return eBuildInstrExpectedEnvPointMember;
  2892.             }
  2893.  
  2894.         switch (GetTokenKeywordTag(Token))
  2895.             {
  2896.                 default:
  2897.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2898.                     return eBuildInstrExpectedEnvPointMember;
  2899.  
  2900.                 case eKeywordSustainpoint:
  2901.                     Token = GetNextToken(Scanner);
  2902.                     if (Token == NIL)
  2903.                         {
  2904.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2905.                             return eBuildInstrNoError;
  2906.                         }
  2907.                     if (GetTokenType(Token) != eTokenInteger)
  2908.                         {
  2909.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2910.                             return eBuildInstrExpectedInteger;
  2911.                         }
  2912.                     switch (GetTokenIntegerValue(Token))
  2913.                         {
  2914.                             default:
  2915.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2916.                                 return eBuildInstrExpectedIntBetween1And3;
  2917.                             case 1:
  2918.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2919.                                     {
  2920.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2921.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2922.                                     }
  2923.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2924.                                     eEnvelopeSustainPointSkip);
  2925.                                 break;
  2926.                             case 2:
  2927.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2928.                                     {
  2929.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2930.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2931.                                     }
  2932.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2933.                                     eEnvelopeSustainPointSkip);
  2934.                                 break;
  2935.                             case 3:
  2936.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2937.                                     {
  2938.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2939.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2940.                                     }
  2941.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2942.                                     eEnvelopeSustainPointSkip);
  2943.                                 break;
  2944.                         }
  2945.                     break;
  2946.  
  2947.                 case eKeywordReleasepoint:
  2948.                     Token = GetNextToken(Scanner);
  2949.                     if (Token == NIL)
  2950.                         {
  2951.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2952.                             return eBuildInstrNoError;
  2953.                         }
  2954.                     if (GetTokenType(Token) != eTokenInteger)
  2955.                         {
  2956.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2957.                             return eBuildInstrExpectedInteger;
  2958.                         }
  2959.                     switch (GetTokenIntegerValue(Token))
  2960.                         {
  2961.                             default:
  2962.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2963.                                 return eBuildInstrExpectedIntBetween1And3;
  2964.                             case 1:
  2965.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2966.                                     {
  2967.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2968.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2969.                                     }
  2970.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2971.                                     eEnvelopeReleasePointSkip);
  2972.                                 break;
  2973.                             case 2:
  2974.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2975.                                     {
  2976.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2977.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2978.                                     }
  2979.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2980.                                     eEnvelopeReleasePointSkip);
  2981.                                 break;
  2982.                             case 3:
  2983.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2984.                                     {
  2985.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2986.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2987.                                     }
  2988.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2989.                                     eEnvelopeReleasePointSkip);
  2990.                                 break;
  2991.                         }
  2992.                     break;
  2993.  
  2994.                 case eKeywordSustainpointnoskip:
  2995.                     Token = GetNextToken(Scanner);
  2996.                     if (Token == NIL)
  2997.                         {
  2998.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2999.                             return eBuildInstrNoError;
  3000.                         }
  3001.                     if (GetTokenType(Token) != eTokenInteger)
  3002.                         {
  3003.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3004.                             return eBuildInstrExpectedInteger;
  3005.                         }
  3006.                     switch (GetTokenIntegerValue(Token))
  3007.                         {
  3008.                             default:
  3009.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3010.                                 return eBuildInstrExpectedIntBetween1And3;
  3011.                             case 1:
  3012.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  3013.                                     {
  3014.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  3015.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  3016.                                     }
  3017.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3018.                                     eEnvelopeSustainPointNoSkip);
  3019.                                 break;
  3020.                             case 2:
  3021.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  3022.                                     {
  3023.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  3024.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  3025.                                     }
  3026.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3027.                                     eEnvelopeSustainPointNoSkip);
  3028.                                 break;
  3029.                             case 3:
  3030.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  3031.                                     {
  3032.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  3033.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  3034.                                     }
  3035.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3036.                                     eEnvelopeSustainPointNoSkip);
  3037.                                 break;
  3038.                         }
  3039.                     break;
  3040.  
  3041.                 case eKeywordReleasepointnoskip:
  3042.                     Token = GetNextToken(Scanner);
  3043.                     if (Token == NIL)
  3044.                         {
  3045.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3046.                             return eBuildInstrNoError;
  3047.                         }
  3048.                     if (GetTokenType(Token) != eTokenInteger)
  3049.                         {
  3050.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3051.                             return eBuildInstrExpectedInteger;
  3052.                         }
  3053.                     switch (GetTokenIntegerValue(Token))
  3054.                         {
  3055.                             default:
  3056.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3057.                                 return eBuildInstrExpectedIntBetween1And3;
  3058.                             case 1:
  3059.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  3060.                                     {
  3061.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  3062.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  3063.                                     }
  3064.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3065.                                     eEnvelopeReleasePointNoSkip);
  3066.                                 break;
  3067.                             case 2:
  3068.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  3069.                                     {
  3070.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  3071.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  3072.                                     }
  3073.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3074.                                     eEnvelopeReleasePointNoSkip);
  3075.                                 break;
  3076.                             case 3:
  3077.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  3078.                                     {
  3079.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  3080.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  3081.                                     }
  3082.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3083.                                     eEnvelopeReleasePointNoSkip);
  3084.                                 break;
  3085.                         }
  3086.                     break;
  3087.  
  3088.                 case eKeywordAmpaccent1:
  3089.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT1) != 0)
  3090.                         {
  3091.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3092.                             return eBuildInstrMultipleEnvPointAmpAccent1;
  3093.                         }
  3094.  
  3095.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3096.                     if (Error != eBuildInstrNoError)
  3097.                         {
  3098.                             return Error;
  3099.                         }
  3100.                     EnvelopeSetAccent1Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3101.  
  3102.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT1;
  3103.                     break;
  3104.  
  3105.                 case eKeywordAmpaccent2:
  3106.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT2) != 0)
  3107.                         {
  3108.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3109.                             return eBuildInstrMultipleEnvPointAmpAccent2;
  3110.                         }
  3111.  
  3112.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3113.                     if (Error != eBuildInstrNoError)
  3114.                         {
  3115.                             return Error;
  3116.                         }
  3117.                     EnvelopeSetAccent2Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3118.  
  3119.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT2;
  3120.                     break;
  3121.  
  3122.                 case eKeywordAmpaccent3:
  3123.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT3) != 0)
  3124.                         {
  3125.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3126.                             return eBuildInstrMultipleEnvPointAmpAccent3;
  3127.                         }
  3128.  
  3129.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3130.                     if (Error != eBuildInstrNoError)
  3131.                         {
  3132.                             return Error;
  3133.                         }
  3134.                     EnvelopeSetAccent3Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3135.  
  3136.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT3;
  3137.                     break;
  3138.  
  3139.                 case eKeywordAmpaccent4:
  3140.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT4) != 0)
  3141.                         {
  3142.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3143.                             return eBuildInstrMultipleEnvPointAmpAccent4;
  3144.                         }
  3145.  
  3146.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3147.                     if (Error != eBuildInstrNoError)
  3148.                         {
  3149.                             return Error;
  3150.                         }
  3151.                     EnvelopeSetAccent4Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3152.  
  3153.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT4;
  3154.                     break;
  3155.  
  3156.                 case eKeywordAmpfreq:
  3157.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPFREQ) != 0)
  3158.                         {
  3159.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3160.                             return eBuildInstrMultipleEnvPointAmpFreq;
  3161.                         }
  3162.  
  3163.                     Token = GetNextToken(Scanner);
  3164.                     if (Token == NIL)
  3165.                         {
  3166.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3167.                             return eBuildInstrNoError;
  3168.                         }
  3169.                     if ((GetTokenType(Token) != eTokenKeyword)
  3170.                         || (GetTokenKeywordTag(Token) != eKeywordSlope))
  3171.                         {
  3172.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3173.                             return eBuildInstrExpectedSlope;
  3174.                         }
  3175.  
  3176.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3177.                     if (Error != eBuildInstrNoError)
  3178.                         {
  3179.                             return Error;
  3180.                         }
  3181.                     EnvelopeSetFreqAmpRolloff(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3182.  
  3183.                     Token = GetNextToken(Scanner);
  3184.                     if (Token == NIL)
  3185.                         {
  3186.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3187.                             return eBuildInstrNoError;
  3188.                         }
  3189.                     if ((GetTokenType(Token) != eTokenKeyword)
  3190.                         || (GetTokenKeywordTag(Token) != eKeywordCenter))
  3191.                         {
  3192.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3193.                             return eBuildInstrExpectedCenter;
  3194.                         }
  3195.  
  3196.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3197.                     if (Error != eBuildInstrNoError)
  3198.                         {
  3199.                             return Error;
  3200.                         }
  3201.                     EnvelopeSetFreqAmpNormalization(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3202.  
  3203.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPFREQ;
  3204.                     break;
  3205.  
  3206.                 case eKeywordRateaccent1:
  3207.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT1) != 0)
  3208.                         {
  3209.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3210.                             return eBuildInstrMultipleEnvPointRateAccent1;
  3211.                         }
  3212.  
  3213.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3214.                     if (Error != eBuildInstrNoError)
  3215.                         {
  3216.                             return Error;
  3217.                         }
  3218.                     EnvelopeSetAccent1Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3219.  
  3220.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT1;
  3221.                     break;
  3222.  
  3223.                 case eKeywordRateaccent2:
  3224.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT2) != 0)
  3225.                         {
  3226.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3227.                             return eBuildInstrMultipleEnvPointRateAccent2;
  3228.                         }
  3229.  
  3230.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3231.                     if (Error != eBuildInstrNoError)
  3232.                         {
  3233.                             return Error;
  3234.                         }
  3235.                     EnvelopeSetAccent2Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3236.  
  3237.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT2;
  3238.                     break;
  3239.  
  3240.                 case eKeywordRateaccent3:
  3241.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT3) != 0)
  3242.                         {
  3243.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3244.                             return eBuildInstrMultipleEnvPointRateAccent3;
  3245.                         }
  3246.  
  3247.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3248.                     if (Error != eBuildInstrNoError)
  3249.                         {
  3250.                             return Error;
  3251.                         }
  3252.                     EnvelopeSetAccent3Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3253.  
  3254.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT3;
  3255.                     break;
  3256.  
  3257.                 case eKeywordRateaccent4:
  3258.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT4) != 0)
  3259.                         {
  3260.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3261.                             return eBuildInstrMultipleEnvPointRateAccent4;
  3262.                         }
  3263.  
  3264.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3265.                     if (Error != eBuildInstrNoError)
  3266.                         {
  3267.                             return Error;
  3268.                         }
  3269.                     EnvelopeSetAccent4Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3270.  
  3271.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT4;
  3272.                     break;
  3273.  
  3274.                 case eKeywordRatefreq:
  3275.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEFREQ) != 0)
  3276.                         {
  3277.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3278.                             return eBuildInstrMultipleEnvPointRateFreq;
  3279.                         }
  3280.  
  3281.                     Token = GetNextToken(Scanner);
  3282.                     if (Token == NIL)
  3283.                         {
  3284.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3285.                             return eBuildInstrNoError;
  3286.                         }
  3287.                     if ((GetTokenType(Token) != eTokenKeyword)
  3288.                         || (GetTokenKeywordTag(Token) != eKeywordSlope))
  3289.                         {
  3290.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3291.                             return eBuildInstrExpectedSlope;
  3292.                         }
  3293.  
  3294.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3295.                     if (Error != eBuildInstrNoError)
  3296.                         {
  3297.                             return Error;
  3298.                         }
  3299.                     EnvelopeSetFreqRateRolloff(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3300.  
  3301.                     Token = GetNextToken(Scanner);
  3302.                     if (Token == NIL)
  3303.                         {
  3304.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3305.                             return eBuildInstrNoError;
  3306.                         }
  3307.                     if ((GetTokenType(Token) != eTokenKeyword)
  3308.                         || (GetTokenKeywordTag(Token) != eKeywordCenter))
  3309.                         {
  3310.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3311.                             return eBuildInstrExpectedCenter;
  3312.                         }
  3313.  
  3314.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3315.                     if (Error != eBuildInstrNoError)
  3316.                         {
  3317.                             return Error;
  3318.                         }
  3319.                     EnvelopeSetFreqRateNormalization(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3320.  
  3321.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEFREQ;
  3322.                     break;
  3323.  
  3324.                 case eKeywordExponential:
  3325.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_CURVE) != 0)
  3326.                         {
  3327.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3328.                             return eBuildInstrMultipleEnvPointCurveSpec;
  3329.                         }
  3330.  
  3331.                     EnvelopeSetPhaseTransitionType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3332.                         eEnvelopeLinearInDecibels);
  3333.  
  3334.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_CURVE;
  3335.                     break;
  3336.  
  3337.                 case eKeywordLinear:
  3338.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_CURVE) != 0)
  3339.                         {
  3340.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3341.                             return eBuildInstrMultipleEnvPointCurveSpec;
  3342.                         }
  3343.  
  3344.                     EnvelopeSetPhaseTransitionType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3345.                         eEnvelopeLinearInAmplitude);
  3346.  
  3347.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_CURVE;
  3348.                     break;
  3349.             }
  3350.  
  3351.         return eBuildInstrNoError;
  3352.     }
  3353.  
  3354.  
  3355.  
  3356.  
  3357. /*    1:                   ::= delayline ( <delayelemlist> )  */
  3358. /*  XXX:                   ::= nlproc wavetable <string> inputscaling <number> */
  3359. /*                             outputscaling <number> wavetableindex <number> */
  3360. /*                             <nlattributes> */
  3361. /*  XXX:                   ::= filter ( <filterstuff> ) */
  3362. /*  XXX:                   ::= analyzer <string> */
  3363. /* FOLLOW SET */
  3364. /* { ; } */
  3365. static BuildInstrErrors            ParseTrackEffect(EffectSpecListRec* EffectList,
  3366.                                                             ScannerRec* Scanner, long *ErrorLine,
  3367.                                                             WaveTableListRec* WaveTableList,
  3368.                                                             AlgoWaveTableListRec* AlgoWaveTableList)
  3369.     {
  3370.         TokenRec*                                    Token;
  3371.         BuildInstrErrors                    Error;
  3372.         unsigned long                            OnceOnlyEnforcer;
  3373.  
  3374.         Token = GetNextToken(Scanner);
  3375.         if (Token == NIL)
  3376.             {
  3377.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3378.                 return eBuildInstrOutOfMemory;
  3379.             }
  3380.         if (GetTokenType(Token) != eTokenKeyword)
  3381.             {
  3382.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3383.                 return eBuildInstrExpectedEffectName;
  3384.             }
  3385.  
  3386.         switch (GetTokenKeywordTag(Token))
  3387.             {
  3388.                 default:
  3389.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  3390.                     return eBuildInstrExpectedEffectName;
  3391.  
  3392.                 case eKeywordAnalyzer:
  3393.                     {
  3394.                         char*                                        IDString;
  3395.                         AnalyzerSpecRec*                Analyzer;
  3396.  
  3397.                         Error = ParseIdentifier(Scanner,ErrorLine,&IDString);
  3398.                         if (Error != eBuildInstrNoError)
  3399.                             {
  3400.                                 return Error;
  3401.                             }
  3402.                         Analyzer = NewAnalyzerSpec(IDString);
  3403.                         ReleasePtr(IDString);
  3404.                         if (Analyzer == NIL)
  3405.                             {
  3406.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3407.                                 return eBuildInstrOutOfMemory;
  3408.                             }
  3409.                         if (!AddAnalyzerToEffectSpecList(EffectList,Analyzer))
  3410.                             {
  3411.                                 DisposeAnalyzerSpec(Analyzer);
  3412.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3413.                                 return eBuildInstrOutOfMemory;
  3414.                             }
  3415.                     }
  3416.                     break;
  3417.  
  3418.                 case eKeywordFilter:
  3419.                     {
  3420.                         FilterSpecRec*                    FilterSpec;
  3421.  
  3422.                         Token = GetNextToken(Scanner);
  3423.                         if (Token == NIL)
  3424.                             {
  3425.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3426.                                 return eBuildInstrOutOfMemory;
  3427.                             }
  3428.                         if (GetTokenType(Token) != eTokenOpenParen)
  3429.                             {
  3430.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3431.                                 return eBuildInstrExpectedOpenParen;
  3432.                             }
  3433.  
  3434.                         FilterSpec = NewFilterSpec();
  3435.                         if (FilterSpec == NIL)
  3436.                             {
  3437.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3438.                                 return eBuildInstrOutOfMemory;
  3439.                             }
  3440.                         if (!AddFilterToEffectSpecList(EffectList,FilterSpec))
  3441.                             {
  3442.                                 DisposeFilterSpec(FilterSpec);
  3443.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3444.                                 return eBuildInstrOutOfMemory;
  3445.                             }
  3446.  
  3447.                         Error = ParseFilterList(FilterSpec,Scanner,ErrorLine);
  3448.                         if (Error != eBuildInstrNoError)
  3449.                             {
  3450.                                 return Error;
  3451.                             }
  3452.  
  3453.                         Token = GetNextToken(Scanner);
  3454.                         if (Token == NIL)
  3455.                             {
  3456.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3457.                                 return eBuildInstrOutOfMemory;
  3458.                             }
  3459.                         if (GetTokenType(Token) != eTokenCloseParen)
  3460.                             {
  3461.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3462.                                 return eBuildInstrExpectedCloseParen;
  3463.                             }
  3464.                     }
  3465.                     break;
  3466.  
  3467.                 case eKeywordNlproc:
  3468.                     {
  3469.                         struct WaveTableObjectRec*            DataWaveTable;
  3470.                         struct AlgoWaveTableObjectRec*    AlgoWaveTable;
  3471.                         char*                                                        WaveTableName;
  3472.                         NonlinProcSpecRec*                            NLProcSpec;
  3473.                         double                                                    Number;
  3474.  
  3475.                         /* toss 'wavetable' */
  3476.                         Token = GetNextToken(Scanner);
  3477.                         if (Token == NIL)
  3478.                             {
  3479.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3480.                                 return eBuildInstrOutOfMemory;
  3481.                             }
  3482.                         if ((GetTokenType(Token) != eTokenKeyword)
  3483.                             || (GetTokenKeywordTag(Token) != eKeywordWavetable))
  3484.                             {
  3485.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3486.                                 return eBuildInstrExpectedWavetable;
  3487.                             }
  3488.                         /* get wavetable name */
  3489.                         Error = ParseIdentifier(Scanner,ErrorLine,&WaveTableName);
  3490.                         if (Error != eBuildInstrNoError)
  3491.                             {
  3492.                                 return Error;
  3493.                             }
  3494.                         DataWaveTable = WaveTableListLookupNamedWaveTable(WaveTableList,
  3495.                             WaveTableName);
  3496.                         if (DataWaveTable != NIL)
  3497.                             {
  3498.                                 NLProcSpec = NewNonlinProcSpecDataWave(DataWaveTable);
  3499.                                 if (NLProcSpec == NIL)
  3500.                                     {
  3501.                                         ReleasePtr(WaveTableName);
  3502.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  3503.                                         return eBuildInstrOutOfMemory;
  3504.                                     }
  3505.                             }
  3506.                          else
  3507.                             {
  3508.                                 AlgoWaveTable = AlgoWaveTableListLookupNamedAlgoWaveTable(
  3509.                                     AlgoWaveTableList,WaveTableName);
  3510.                                 if (AlgoWaveTable == NIL)
  3511.                                     {
  3512.                                         ReleasePtr(WaveTableName);
  3513.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  3514.                                         return eBuildInstrUndefinedWavetable;
  3515.                                     }
  3516.                                 NLProcSpec = NewNonlinProcSpecAlgoWave(AlgoWaveTable);
  3517.                                 if (NLProcSpec == NIL)
  3518.                                     {
  3519.                                         ReleasePtr(WaveTableName);
  3520.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  3521.                                         return eBuildInstrOutOfMemory;
  3522.                                     }
  3523.                             }
  3524.                         ReleasePtr(WaveTableName);
  3525.                         if (!AddNLProcToEffectSpecList(EffectList,NLProcSpec))
  3526.                             {
  3527.                                 DisposeNonlinProcSpec(NLProcSpec);
  3528.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3529.                                 return eBuildInstrOutOfMemory;
  3530.                             }
  3531.                         /* toss 'inputscaling' */
  3532.                         Token = GetNextToken(Scanner);
  3533.                         if (Token == NIL)
  3534.                             {
  3535.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3536.                                 return eBuildInstrOutOfMemory;
  3537.                             }
  3538.                         if ((GetTokenType(Token) != eTokenKeyword)
  3539.                             || (GetTokenKeywordTag(Token) != eKeywordInputscaling))
  3540.                             {
  3541.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3542.                                 return eBuildInstrExpectedInputscaling;
  3543.                             }
  3544.                         /* get input scaling value */
  3545.                         Error = ParseNumber(Scanner,ErrorLine,&Number);
  3546.                         if (Error != eBuildInstrNoError)
  3547.                             {
  3548.                                 return Error;
  3549.                             }
  3550.                         PutNLProcInputScaling(NLProcSpec,Number);
  3551.                         /* toss 'outputscaling' */
  3552.                         Token = GetNextToken(Scanner);
  3553.                         if (Token == NIL)
  3554.                             {
  3555.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3556.                                 return eBuildInstrOutOfMemory;
  3557.                             }
  3558.                         if ((GetTokenType(Token) != eTokenKeyword)
  3559.                             || (GetTokenKeywordTag(Token) != eKeywordOutputscaling))
  3560.                             {
  3561.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3562.                                 return eBuildInstrExpectedOutputscaling;
  3563.                             }
  3564.                         /* get the output scaling value */
  3565.                         Error = ParseNumber(Scanner,ErrorLine,&Number);
  3566.                         if (Error != eBuildInstrNoError)
  3567.                             {
  3568.                                 return Error;
  3569.                             }
  3570.                         PutNLProcOutputScaling(NLProcSpec,Number);
  3571.                         /* toss 'wavetableindex' */
  3572.                         Token = GetNextToken(Scanner);
  3573.                         if (Token == NIL)
  3574.                             {
  3575.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3576.                                 return eBuildInstrOutOfMemory;
  3577.                             }
  3578.                         if ((GetTokenType(Token) != eTokenKeyword)
  3579.                             || (GetTokenKeywordTag(Token) != eKeywordWavetableindex))
  3580.                             {
  3581.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3582.                                 return eBuildInstrExpectedWavetableindex;
  3583.                             }
  3584.                         /* get wave table index */
  3585.                         Error = ParseNumber(Scanner,ErrorLine,&Number);
  3586.                         if (Error != eBuildInstrNoError)
  3587.                             {
  3588.                                 return Error;
  3589.                             }
  3590.                         PutNLProcWaveTableIndex(NLProcSpec,Number);
  3591.                         /* parse attributes */
  3592.                         OnceOnlyEnforcer = 0;
  3593.                         Error = ParseNLAttributes(NLProcSpec,Scanner,ErrorLine,&OnceOnlyEnforcer);
  3594.                         if (Error != eBuildInstrNoError)
  3595.                             {
  3596.                                 return Error;
  3597.                             }
  3598.                     }
  3599.                     break;
  3600.  
  3601.                 case eKeywordDelayline:
  3602.                     {
  3603.                         DelayEffectRec*                        DelayEffect;
  3604.  
  3605.                         DelayEffect = NewDelayLineSpec();
  3606.                         if (DelayEffect == NIL)
  3607.                             {
  3608.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3609.                                 return eBuildInstrOutOfMemory;
  3610.                             }
  3611.                         if (!AddDelayToEffectSpecList(EffectList,DelayEffect))
  3612.                             {
  3613.                                 DisposeDelayLineSpec(DelayEffect);
  3614.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3615.                                 return eBuildInstrOutOfMemory;
  3616.                             }
  3617.                         Token = GetNextToken(Scanner);
  3618.                         if (Token == NIL)
  3619.                             {
  3620.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3621.                                 return eBuildInstrOutOfMemory;
  3622.                             }
  3623.                         if (GetTokenType(Token) != eTokenOpenParen)
  3624.                             {
  3625.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3626.                                 return eBuildInstrExpectedOpenParen;
  3627.                             }
  3628.                         OnceOnlyEnforcer = 0;
  3629.                         Error = ParseDelayElemList(DelayEffect,Scanner,ErrorLine,&OnceOnlyEnforcer);
  3630.                         if (Error != eBuildInstrNoError)
  3631.                             {
  3632.                                 return Error;
  3633.                             }
  3634.                         Token = GetNextToken(Scanner);
  3635.                         if (Token == NIL)
  3636.                             {
  3637.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3638.                                 return eBuildInstrOutOfMemory;
  3639.                             }
  3640.                         if (GetTokenType(Token) != eTokenCloseParen)
  3641.                             {
  3642.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3643.                                 return eBuildInstrExpectedCloseParen;
  3644.                             }
  3645.                     }
  3646.                     break;
  3647.             }
  3648.  
  3649.         return eBuildInstrNoError;
  3650.     }
  3651.  
  3652.  
  3653.  
  3654.  
  3655. /*    2:   <delayelemlist> ::= <delayelem> ; <delayelemlist>  */
  3656. /*    3:                   ::=   */
  3657. /* FIRST SET */
  3658. /*  <delayelemlist> : {tap, <delayelem>} */
  3659. /* FOLLOW SET */
  3660. /*  <delayelemlist> : {)} */
  3661. static BuildInstrErrors            ParseDelayElemList(DelayEffectRec* DelayEffect,
  3662.                                                             ScannerRec* Scanner, long *ErrorLine,
  3663.                                                             unsigned long* OnceOnlyDefinitions)
  3664.     {
  3665.         TokenRec*                                    Token;
  3666.         BuildInstrErrors                    Error;
  3667.  
  3668.         Token = GetNextToken(Scanner);
  3669.         if (Token == NIL)
  3670.             {
  3671.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3672.                 return eBuildInstrOutOfMemory;
  3673.             }
  3674.         if (GetTokenType(Token) == eTokenCloseParen)
  3675.             {
  3676.                 UngetToken(Scanner,Token);
  3677.                 return eBuildInstrNoError;
  3678.             }
  3679.  
  3680.         UngetToken(Scanner,Token);
  3681.         Error = ParseDelayElem(DelayEffect,Scanner,ErrorLine,OnceOnlyDefinitions);
  3682.         if (Error != eBuildInstrNoError)
  3683.             {
  3684.                 return Error;
  3685.             }
  3686.  
  3687.         Token = GetNextToken(Scanner);
  3688.         if (Token == NIL)
  3689.             {
  3690.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3691.                 return eBuildInstrOutOfMemory;
  3692.             }
  3693.         if (GetTokenType(Token) != eTokenSemicolon)
  3694.             {
  3695.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3696.                 return eBuildInstrExpectedSemicolon;
  3697.             }
  3698.  
  3699.         return ParseDelayElemList(DelayEffect,Scanner,ErrorLine,OnceOnlyDefinitions);
  3700.     }
  3701.  
  3702.  
  3703.  
  3704.  
  3705. /*    6:                   ::= tap <tapsource> <number> to <tapsource> <number> */
  3706. /*                             scale <number> <tapattributes>  */
  3707. /*  XXX:                   ::= maxdelaytime <number> */
  3708. static BuildInstrErrors            ParseDelayElem(DelayEffectRec* DelayEffect,
  3709.                                                             ScannerRec* Scanner, long *ErrorLine,
  3710.                                                             unsigned long* OnceOnlyDefinitions)
  3711.     {
  3712.         TokenRec*                                    Token;
  3713.         BuildInstrErrors                    Error;
  3714.         double                                        Number;
  3715.         unsigned long                            OnceOnlyGuard;
  3716.  
  3717.         Token = GetNextToken(Scanner);
  3718.         if (Token == NIL)
  3719.             {
  3720.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3721.                 return eBuildInstrOutOfMemory;
  3722.             }
  3723.         if (GetTokenType(Token) != eTokenKeyword)
  3724.             {
  3725.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3726.                 return eBuildInstrExpectedDelayLineElem;
  3727.             }
  3728.  
  3729.         switch (GetTokenKeywordTag(Token))
  3730.             {
  3731.                 default:
  3732.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  3733.                     return eBuildInstrExpectedDelayLineElem;
  3734.                 case eKeywordMaxdelaytime: /* maxdelaytime <number> */
  3735.                     if ((*OnceOnlyDefinitions & DELAYEFFECT_ONCEONLY_MAXDELAYTIME) != 0)
  3736.                         {
  3737.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3738.                             return eBuildInstrMultipleMaxDelayTime;
  3739.                         }
  3740.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3741.                     if (Error != eBuildInstrNoError)
  3742.                         {
  3743.                             return Error;
  3744.                         }
  3745.                     SetDelayMaxTime(DelayEffect,Number);
  3746.                     *OnceOnlyDefinitions |= DELAYEFFECT_ONCEONLY_MAXDELAYTIME;
  3747.                     break;
  3748.                 case eKeywordTap:
  3749.                     {
  3750.                         DelayTapRec*                    Tap;
  3751.                         double                                Number;
  3752.                         unsigned long                    OnceOnlyGuard;
  3753.  
  3754.                         /* tap <tapsource> <number> to <tapsource> <number> scale */
  3755.                         /* <number> <tapattributes>  */
  3756.                         /* --- <tapsource> == {left, right, mono} */
  3757.                         Tap = NewDelayTap();
  3758.                         if (Tap == NIL)
  3759.                             {
  3760.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3761.                                 return eBuildInstrOutOfMemory;
  3762.                             }
  3763.                         if (!AppendTapToDelayEffect(DelayEffect,Tap))
  3764.                             {
  3765.                                 DisposeDelayTap(Tap);
  3766.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3767.                                 return eBuildInstrOutOfMemory;
  3768.                             }
  3769.                         /* do source */
  3770.                         Token = GetNextToken(Scanner);
  3771.                         if (Token == NIL)
  3772.                             {
  3773.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3774.                                 return eBuildInstrOutOfMemory;
  3775.                             }
  3776.                         if (GetTokenType(Token) != eTokenKeyword)
  3777.                             {
  3778.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3779.                                 return eBuildInstrExpectedTapChannel;
  3780.                             }
  3781.                         switch (GetTokenKeywordTag(Token))
  3782.                             {
  3783.                                 default:
  3784.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  3785.                                     return eBuildInstrExpectedTapChannel;
  3786.                                 case eKeywordLeft:
  3787.                                     SetDelayTapSource(Tap,eTapLeftChannel);
  3788.                                     break;
  3789.                                 case eKeywordRight:
  3790.                                     SetDelayTapSource(Tap,eTapRightChannel);
  3791.                                     break;
  3792.                                 case eKeywordMono:
  3793.                                     SetDelayTapSource(Tap,eTapMonoChannel);
  3794.                                     break;
  3795.                             }
  3796.                         /* get source delay time */
  3797.                         Error = ParseNumber(Scanner,ErrorLine,&Number);
  3798.                         if (Error != eBuildInstrNoError)
  3799.                             {
  3800.                                 return Error;
  3801.                             }
  3802.                         SetDelayTapSourceTime(Tap,Number);
  3803.                         /* eat "to" */
  3804.                         Token = GetNextToken(Scanner);
  3805.                         if (Token == NIL)
  3806.                             {
  3807.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3808.                                 return eBuildInstrOutOfMemory;
  3809.                             }
  3810.                         if ((GetTokenType(Token) != eTokenKeyword)
  3811.                             || (GetTokenKeywordTag(Token) != eKeywordTo))
  3812.                             {
  3813.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3814.                                 return eBuildInstrExpectedTo;
  3815.                             }
  3816.                         /* tap target */
  3817.                         Token = GetNextToken(Scanner);
  3818.                         if (Token == NIL)
  3819.                             {
  3820.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3821.                                 return eBuildInstrOutOfMemory;
  3822.                             }
  3823.                         if (GetTokenType(Token) != eTokenKeyword)
  3824.                             {
  3825.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3826.                                 return eBuildInstrExpectedTapChannel;
  3827.                             }
  3828.                         switch (GetTokenKeywordTag(Token))
  3829.                             {
  3830.                                 default:
  3831.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  3832.                                     return eBuildInstrExpectedTapChannel;
  3833.                                 case eKeywordLeft:
  3834.                                     SetDelayTapTarget(Tap,eTapLeftChannel);
  3835.                                     break;
  3836.                                 case eKeywordRight:
  3837.                                     SetDelayTapTarget(Tap,eTapRightChannel);
  3838.                                     break;
  3839.                                 case eKeywordMono:
  3840.                                     SetDelayTapTarget(Tap,eTapMonoChannel);
  3841.                                     break;
  3842.                             }
  3843.                         /* get target delay time */
  3844.                         Error = ParseNumber(Scanner,ErrorLine,&Number);
  3845.                         if (Error != eBuildInstrNoError)
  3846.                             {
  3847.                                 return Error;
  3848.                             }
  3849.                         SetDelayTapTargetTime(Tap,Number);
  3850.                         /* eat "scale" */
  3851.                         Token = GetNextToken(Scanner);
  3852.                         if (Token == NIL)
  3853.                             {
  3854.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3855.                                 return eBuildInstrOutOfMemory;
  3856.                             }
  3857.                         if ((GetTokenType(Token) != eTokenKeyword)
  3858.                             || (GetTokenKeywordTag(Token) != eKeywordScale))
  3859.                             {
  3860.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3861.                                 return eBuildInstrExpectedScale;
  3862.                             }
  3863.                         /* get scaling number */
  3864.                         Error = ParseNumber(Scanner,ErrorLine,&Number);
  3865.                         if (Error != eBuildInstrNoError)
  3866.                             {
  3867.                                 return Error;
  3868.                             }
  3869.                         SetDelayTapScale(Tap,Number);
  3870.                         /* do attributes */
  3871.                         OnceOnlyGuard = 0;
  3872.                         Error = ParseTapAttributes(Tap,Scanner,ErrorLine,&OnceOnlyGuard);
  3873.                         if (Error != eBuildInstrNoError)
  3874.                             {
  3875.                                 return Error;
  3876.                             }
  3877.                     }
  3878.                     break;
  3879.             }
  3880.  
  3881.         return eBuildInstrNoError;
  3882.     }
  3883.  
  3884.  
  3885.  
  3886.  
  3887. /*   13:   <tapattributes> ::= <tapattr> <tapattributes> */
  3888. /*   26:                   ::=  */
  3889. /* FOLLOW SET */
  3890. /*  <tapattributes> : {;} */
  3891. static BuildInstrErrors            ParseTapAttributes(DelayTapRec* Tap,
  3892.                                                             ScannerRec* Scanner, long *ErrorLine,
  3893.                                                             unsigned long* OnceOnlyDefinitions)
  3894.     {
  3895.         TokenRec*                                    Token;
  3896.         BuildInstrErrors                    Error;
  3897.  
  3898.         Token = GetNextToken(Scanner);
  3899.         if (Token == NIL)
  3900.             {
  3901.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3902.                 return eBuildInstrOutOfMemory;
  3903.             }
  3904.         if (GetTokenType(Token) == eTokenSemicolon)
  3905.             {
  3906.                 UngetToken(Scanner,Token);
  3907.                 return eBuildInstrNoError;
  3908.             }
  3909.         UngetToken(Scanner,Token);
  3910.  
  3911.         Error = ParseTapAttr(Tap,Scanner,ErrorLine,OnceOnlyDefinitions);
  3912.         if (Error != eBuildInstrNoError)
  3913.             {
  3914.                 return Error;
  3915.             }
  3916.  
  3917.         return ParseTapAttributes(Tap,Scanner,ErrorLine,OnceOnlyDefinitions);
  3918.     }
  3919.  
  3920.  
  3921.  
  3922.  
  3923. /*  14:                   ::= sourceaccent1 <number> */
  3924. /*  15:                   ::= sourceaccent2 <number> */
  3925. /*  16:                   ::= sourceaccent3 <number> */
  3926. /*  17:                   ::= sourceaccent4 <number> */
  3927. /*  18:                   ::= targetaccent1 <number> */
  3928. /*  19:                   ::= targetaccent2 <number> */
  3929. /*  20:                   ::= targetaccent3 <number> */
  3930. /*  21:                   ::= targetaccent4 <number> */
  3931. /*  22:                   ::= scaleaccent1 <number> */
  3932. /*  23:                   ::= scaleaccent2 <number> */
  3933. /*  24:                   ::= scaleaccent3 <number> */
  3934. /*  25:                   ::= scaleaccent4 <number> */
  3935. /*  27:                   ::= movingaveragelowpass */
  3936. static BuildInstrErrors            ParseTapAttr(DelayTapRec* Tap,
  3937.                                                             ScannerRec* Scanner, long *ErrorLine,
  3938.                                                             unsigned long* OnceOnlyDefinitions)
  3939.     {
  3940.         TokenRec*                                    Token;
  3941.         BuildInstrErrors                    Error;
  3942.         double                                        Number;
  3943.  
  3944.         Token = GetNextToken(Scanner);
  3945.         if (Token == NIL)
  3946.             {
  3947.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3948.                 return eBuildInstrOutOfMemory;
  3949.             }
  3950.         if (GetTokenType(Token) != eTokenKeyword)
  3951.             {
  3952.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3953.                 return eBuildInstrExpectedTapAttr;
  3954.             }
  3955.         switch (GetTokenKeywordTag(Token))
  3956.             {
  3957.                 default:
  3958.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  3959.                     return eBuildInstrExpectedTapAttr;
  3960.                 case eKeywordSourceaccent1:
  3961.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT1) != 0)
  3962.                         {
  3963.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3964.                             return eBuildInstrMultipleSourceAccent1;
  3965.                         }
  3966.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3967.                     if (Error != eBuildInstrNoError)
  3968.                         {
  3969.                             return Error;
  3970.                         }
  3971.                     SetDelayTapSourceTimeAccent1(Tap,Number);
  3972.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT1;
  3973.                     break;
  3974.                 case eKeywordSourceaccent2:
  3975.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT2) != 0)
  3976.                         {
  3977.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3978.                             return eBuildInstrMultipleSourceAccent2;
  3979.                         }
  3980.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3981.                     if (Error != eBuildInstrNoError)
  3982.                         {
  3983.                             return Error;
  3984.                         }
  3985.                     SetDelayTapSourceTimeAccent2(Tap,Number);
  3986.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT2;
  3987.                     break;
  3988.                 case eKeywordSourceaccent3:
  3989.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT3) != 0)
  3990.                         {
  3991.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3992.                             return eBuildInstrMultipleSourceAccent3;
  3993.                         }
  3994.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3995.                     if (Error != eBuildInstrNoError)
  3996.                         {
  3997.                             return Error;
  3998.                         }
  3999.                     SetDelayTapSourceTimeAccent3(Tap,Number);
  4000.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT3;
  4001.                     break;
  4002.                 case eKeywordSourceaccent4:
  4003.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT4) != 0)
  4004.                         {
  4005.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4006.                             return eBuildInstrMultipleSourceAccent4;
  4007.                         }
  4008.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4009.                     if (Error != eBuildInstrNoError)
  4010.                         {
  4011.                             return Error;
  4012.                         }
  4013.                     SetDelayTapSourceTimeAccent4(Tap,Number);
  4014.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_SOURCEACCENT4;
  4015.                     break;
  4016.                 case eKeywordTargetaccent1:
  4017.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_TARGETACCENT1) != 0)
  4018.                         {
  4019.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4020.                             return eBuildInstrMultipleTargetAccent1;
  4021.                         }
  4022.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4023.                     if (Error != eBuildInstrNoError)
  4024.                         {
  4025.                             return Error;
  4026.                         }
  4027.                     SetDelayTapTargetTimeAccent1(Tap,Number);
  4028.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_TARGETACCENT1;
  4029.                     break;
  4030.                 case eKeywordTargetaccent2:
  4031.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_TARGETACCENT2) != 0)
  4032.                         {
  4033.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4034.                             return eBuildInstrMultipleTargetAccent2;
  4035.                         }
  4036.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4037.                     if (Error != eBuildInstrNoError)
  4038.                         {
  4039.                             return Error;
  4040.                         }
  4041.                     SetDelayTapTargetTimeAccent2(Tap,Number);
  4042.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_TARGETACCENT2;
  4043.                     break;
  4044.                 case eKeywordTargetaccent3:
  4045.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_TARGETACCENT3) != 0)
  4046.                         {
  4047.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4048.                             return eBuildInstrMultipleTargetAccent3;
  4049.                         }
  4050.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4051.                     if (Error != eBuildInstrNoError)
  4052.                         {
  4053.                             return Error;
  4054.                         }
  4055.                     SetDelayTapTargetTimeAccent3(Tap,Number);
  4056.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_TARGETACCENT3;
  4057.                     break;
  4058.                 case eKeywordTargetaccent4:
  4059.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_TARGETACCENT4) != 0)
  4060.                         {
  4061.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4062.                             return eBuildInstrMultipleTargetAccent4;
  4063.                         }
  4064.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4065.                     if (Error != eBuildInstrNoError)
  4066.                         {
  4067.                             return Error;
  4068.                         }
  4069.                     SetDelayTapTargetTimeAccent4(Tap,Number);
  4070.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_TARGETACCENT4;
  4071.                     break;
  4072.                 case eKeywordScaleaccent1:
  4073.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_SCALEACCENT1) != 0)
  4074.                         {
  4075.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4076.                             return eBuildInstrMultipleScaleAccent1;
  4077.                         }
  4078.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4079.                     if (Error != eBuildInstrNoError)
  4080.                         {
  4081.                             return Error;
  4082.                         }
  4083.                     SetDelayTapScaleAccent1(Tap,Number);
  4084.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_SCALEACCENT1;
  4085.                     break;
  4086.                 case eKeywordScaleaccent2:
  4087.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_SCALEACCENT2) != 0)
  4088.                         {
  4089.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4090.                             return eBuildInstrMultipleScaleAccent2;
  4091.                         }
  4092.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4093.                     if (Error != eBuildInstrNoError)
  4094.                         {
  4095.                             return Error;
  4096.                         }
  4097.                     SetDelayTapScaleAccent2(Tap,Number);
  4098.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_SCALEACCENT2;
  4099.                     break;
  4100.                 case eKeywordScaleaccent3:
  4101.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_SCALEACCENT3) != 0)
  4102.                         {
  4103.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4104.                             return eBuildInstrMultipleScaleAccent3;
  4105.                         }
  4106.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4107.                     if (Error != eBuildInstrNoError)
  4108.                         {
  4109.                             return Error;
  4110.                         }
  4111.                     SetDelayTapScaleAccent3(Tap,Number);
  4112.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_SCALEACCENT3;
  4113.                     break;
  4114.                 case eKeywordScaleaccent4:
  4115.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_SCALEACCENT4) != 0)
  4116.                         {
  4117.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4118.                             return eBuildInstrMultipleScaleAccent4;
  4119.                         }
  4120.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4121.                     if (Error != eBuildInstrNoError)
  4122.                         {
  4123.                             return Error;
  4124.                         }
  4125.                     SetDelayTapScaleAccent4(Tap,Number);
  4126.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_SCALEACCENT4;
  4127.                     break;
  4128.                 case eKeywordMovingaveragelowpass:
  4129.                     if ((*OnceOnlyDefinitions & DELAYEFFECTATTR_ONCEONLY_FILTER) != 0)
  4130.                         {
  4131.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4132.                             return eBuildInstrMultipleFilter;
  4133.                         }
  4134.                     SetDelayTapFilterType(Tap,eTapMovingAverageLP);
  4135.                     *OnceOnlyDefinitions |= DELAYEFFECTATTR_ONCEONLY_FILTER;
  4136.                     break;
  4137.             }
  4138.  
  4139.         return eBuildInstrNoError;
  4140.     }
  4141.  
  4142.  
  4143.  
  4144.  
  4145. /* <nlattributes>         ::= inputaccent1 <number> */
  4146. /*                        ::= inputaccent2 <number> */
  4147. /*                        ::= inputaccent3 <number> */
  4148. /*                        ::= inputaccent4 <number> */
  4149. /*                        ::= outputaccent1 <number> */
  4150. /*                        ::= outputaccent2 <number> */
  4151. /*                        ::= outputaccent3 <number> */
  4152. /*                        ::= outputaccent4 <number> */
  4153. /* FOLLOW SET */
  4154. /*  <nlattributes> : {;} */
  4155. static BuildInstrErrors            ParseNLAttributes(NonlinProcSpecRec* NLProcSpec,
  4156.                                                             ScannerRec* Scanner, long *ErrorLine,
  4157.                                                             unsigned long* OnceOnlyDefinitions)
  4158.     {
  4159.         TokenRec*                                    Token;
  4160.         BuildInstrErrors                    Error;
  4161.         double                                        Number;
  4162.  
  4163.         Token = GetNextToken(Scanner);
  4164.         if (Token == NIL)
  4165.             {
  4166.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4167.                 return eBuildInstrOutOfMemory;
  4168.             }
  4169.         if (GetTokenType(Token) == eTokenSemicolon)
  4170.             {
  4171.                 UngetToken(Scanner,Token);
  4172.                 return eBuildInstrNoError;
  4173.             }
  4174.         if (GetTokenType(Token) != eTokenKeyword)
  4175.             {
  4176.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4177.                 return eBuildInstrExpectedNLAttribute;
  4178.             }
  4179.         switch (GetTokenKeywordTag(Token))
  4180.             {
  4181.                 default:
  4182.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  4183.                     return eBuildInstrExpectedNLAttribute;
  4184.                 case eKeywordInputaccent1:
  4185.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT1) != 0)
  4186.                         {
  4187.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4188.                             return eBuildInstrMultipleInputaccent1;
  4189.                         }
  4190.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4191.                     if (Error != eBuildInstrNoError)
  4192.                         {
  4193.                             return Error;
  4194.                         }
  4195.                     PutNLProcInputAccent1(NLProcSpec,Number);
  4196.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT1;
  4197.                     break;
  4198.                 case eKeywordInputaccent2:
  4199.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT2) != 0)
  4200.                         {
  4201.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4202.                             return eBuildInstrMultipleInputaccent2;
  4203.                         }
  4204.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4205.                     if (Error != eBuildInstrNoError)
  4206.                         {
  4207.                             return Error;
  4208.                         }
  4209.                     PutNLProcInputAccent2(NLProcSpec,Number);
  4210.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT2;
  4211.                     break;
  4212.                 case eKeywordInputaccent3:
  4213.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT3) != 0)
  4214.                         {
  4215.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4216.                             return eBuildInstrMultipleInputaccent3;
  4217.                         }
  4218.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4219.                     if (Error != eBuildInstrNoError)
  4220.                         {
  4221.                             return Error;
  4222.                         }
  4223.                     PutNLProcInputAccent3(NLProcSpec,Number);
  4224.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT3;
  4225.                     break;
  4226.                 case eKeywordInputaccent4:
  4227.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT4) != 0)
  4228.                         {
  4229.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4230.                             return eBuildInstrMultipleInputaccent4;
  4231.                         }
  4232.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4233.                     if (Error != eBuildInstrNoError)
  4234.                         {
  4235.                             return Error;
  4236.                         }
  4237.                     PutNLProcInputAccent4(NLProcSpec,Number);
  4238.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_INPUTACCENT4;
  4239.                     break;
  4240.                 case eKeywordOutputaccent1:
  4241.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT1) != 0)
  4242.                         {
  4243.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4244.                             return eBuildInstrMultipleOutputaccent1;
  4245.                         }
  4246.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4247.                     if (Error != eBuildInstrNoError)
  4248.                         {
  4249.                             return Error;
  4250.                         }
  4251.                     PutNLProcOutputAccent1(NLProcSpec,Number);
  4252.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT1;
  4253.                     break;
  4254.                 case eKeywordOutputaccent2:
  4255.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT2) != 0)
  4256.                         {
  4257.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4258.                             return eBuildInstrMultipleOutputaccent2;
  4259.                         }
  4260.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4261.                     if (Error != eBuildInstrNoError)
  4262.                         {
  4263.                             return Error;
  4264.                         }
  4265.                     PutNLProcOutputAccent2(NLProcSpec,Number);
  4266.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT2;
  4267.                     break;
  4268.                 case eKeywordOutputaccent3:
  4269.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT3) != 0)
  4270.                         {
  4271.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4272.                             return eBuildInstrMultipleOutputaccent3;
  4273.                         }
  4274.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4275.                     if (Error != eBuildInstrNoError)
  4276.                         {
  4277.                             return Error;
  4278.                         }
  4279.                     PutNLProcOutputAccent3(NLProcSpec,Number);
  4280.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT3;
  4281.                     break;
  4282.                 case eKeywordOutputaccent4:
  4283.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT4) != 0)
  4284.                         {
  4285.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4286.                             return eBuildInstrMultipleOutputaccent4;
  4287.                         }
  4288.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4289.                     if (Error != eBuildInstrNoError)
  4290.                         {
  4291.                             return Error;
  4292.                         }
  4293.                     PutNLProcOutputAccent4(NLProcSpec,Number);
  4294.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_OUTPUTACCENT4;
  4295.                     break;
  4296.                 case eKeywordIndexaccent1:
  4297.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT1) != 0)
  4298.                         {
  4299.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4300.                             return eBuildInstrMultipleIndexaccent1;
  4301.                         }
  4302.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4303.                     if (Error != eBuildInstrNoError)
  4304.                         {
  4305.                             return Error;
  4306.                         }
  4307.                     PutNLProcIndexAccent1(NLProcSpec,Number);
  4308.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT1;
  4309.                     break;
  4310.                 case eKeywordIndexaccent2:
  4311.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT2) != 0)
  4312.                         {
  4313.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4314.                             return eBuildInstrMultipleIndexaccent2;
  4315.                         }
  4316.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4317.                     if (Error != eBuildInstrNoError)
  4318.                         {
  4319.                             return Error;
  4320.                         }
  4321.                     PutNLProcIndexAccent2(NLProcSpec,Number);
  4322.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT2;
  4323.                     break;
  4324.                 case eKeywordIndexaccent3:
  4325.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT3) != 0)
  4326.                         {
  4327.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4328.                             return eBuildInstrMultipleIndexaccent3;
  4329.                         }
  4330.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4331.                     if (Error != eBuildInstrNoError)
  4332.                         {
  4333.                             return Error;
  4334.                         }
  4335.                     PutNLProcIndexAccent3(NLProcSpec,Number);
  4336.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT3;
  4337.                     break;
  4338.                 case eKeywordIndexaccent4:
  4339.                     if ((*OnceOnlyDefinitions & NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT4) != 0)
  4340.                         {
  4341.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4342.                             return eBuildInstrMultipleIndexaccent4;
  4343.                         }
  4344.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4345.                     if (Error != eBuildInstrNoError)
  4346.                         {
  4347.                             return Error;
  4348.                         }
  4349.                     PutNLProcIndexAccent4(NLProcSpec,Number);
  4350.                     *OnceOnlyDefinitions |= NLPROCEFFECTATTR_ONCEONLY_INDEXACCENT4;
  4351.                     break;
  4352.             }
  4353.  
  4354.         return ParseNLAttributes(NLProcSpec,Scanner,ErrorLine,OnceOnlyDefinitions);
  4355.     }
  4356.  
  4357.  
  4358.  
  4359.  
  4360. /*  XXX:                   ::= filter <filter> <filterlist> */
  4361. /*  XXX:                   ::= */
  4362. /* FOLLOW SET */
  4363. /* { ) } */
  4364. static BuildInstrErrors            ParseFilterList(FilterSpecRec* FilterSpec,
  4365.                                                             ScannerRec* Scanner, long *ErrorLine)
  4366.     {
  4367.         TokenRec*                                    Token;
  4368.         BuildInstrErrors                    Error;
  4369.  
  4370.         Token = GetNextToken(Scanner);
  4371.         if (Token == NIL)
  4372.             {
  4373.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4374.                 return eBuildInstrOutOfMemory;
  4375.             }
  4376.         if ((GetTokenType(Token) != eTokenKeyword)
  4377.             || (GetTokenKeywordTag(Token) != eKeywordFilter))
  4378.             {
  4379.                 UngetToken(Scanner,Token);
  4380.                 return eBuildInstrNoError;
  4381.             }
  4382.  
  4383.         Error = ParseFilter(FilterSpec,Scanner,ErrorLine);
  4384.         if (Error != eBuildInstrNoError)
  4385.             {
  4386.                 return Error;
  4387.             }
  4388.  
  4389.         return ParseFilterList(FilterSpec,Scanner,ErrorLine);
  4390.     }
  4391.  
  4392.  
  4393.  
  4394.  
  4395. /*  XXX:                   ::= <filtertype> freq <number> <bandwidth> */
  4396. /*                           <scaling> <channel> <filterattributes> ; */
  4397. static BuildInstrErrors            ParseFilter(FilterSpecRec* FilterSpec,
  4398.                                                             ScannerRec* Scanner, long *ErrorLine)
  4399.     {
  4400.         TokenRec*                                    Token;
  4401.         BuildInstrErrors                    Error;
  4402.         FilterTypes                                FilterType;
  4403.         OneFilterRec*                            FilterElement;
  4404.         double                                        Number;
  4405.         unsigned long                            OnceOnlyChecker;
  4406.  
  4407.         /* <filtertype> */
  4408.         Token = GetNextToken(Scanner);
  4409.         if (Token == NIL)
  4410.             {
  4411.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4412.                 return eBuildInstrOutOfMemory;
  4413.             }
  4414.         if (GetTokenType(Token) != eTokenKeyword)
  4415.             {
  4416.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4417.                 return eBuildInstrExpectedFilterType;
  4418.             }
  4419.         switch (GetTokenKeywordTag(Token))
  4420.             {
  4421.                 default:
  4422.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  4423.                     return eBuildInstrExpectedFilterType;
  4424.                 case eKeywordNull:
  4425.                     FilterType = eFilterNull;
  4426.                     break;
  4427.                 case eKeywordLowpass:
  4428.                     FilterType = eFilterFirstOrderLowpass;
  4429.                     break;
  4430.                 case eKeywordHighpass:
  4431.                     FilterType = eFilterFirstOrderHighpass;
  4432.                     break;
  4433.                 case eKeywordReson:
  4434.                     FilterType = eFilterSecondOrderResonant;
  4435.                     break;
  4436.                 case eKeywordZero:
  4437.                     FilterType = eFilterSecondOrderZero;
  4438.                     break;
  4439.                 case eKeywordButterworthlowpass:
  4440.                     FilterType = eFilterButterworthLowpass;
  4441.                     break;
  4442.                 case eKeywordButterworthhighpass:
  4443.                     FilterType = eFilterButterworthHighpass;
  4444.                     break;
  4445.                 case eKeywordButterworthbandpass:
  4446.                     FilterType = eFilterButterworthBandpass;
  4447.                     break;
  4448.                 case eKeywordButterworthbandreject:
  4449.                     FilterType = eFilterButterworthBandreject;
  4450.                     break;
  4451.             }
  4452.  
  4453.         FilterElement = NewSingleFilterSpec(FilterType);
  4454.         if (FilterElement == NIL)
  4455.             {
  4456.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4457.                 return eBuildInstrOutOfMemory;
  4458.             }
  4459.         if (!AppendFilterToSpec(FilterSpec,FilterElement))
  4460.             {
  4461.                 DisposeSingleFilterSpec(FilterElement);
  4462.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4463.                 return eBuildInstrOutOfMemory;
  4464.             }
  4465.  
  4466.         /* freq <number> */
  4467.         if (FilterType != eFilterNull)
  4468.             {
  4469.                 Token = GetNextToken(Scanner);
  4470.                 if (Token == NIL)
  4471.                     {
  4472.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  4473.                         return eBuildInstrOutOfMemory;
  4474.                     }
  4475.                 if ((GetTokenType(Token) != eTokenKeyword)
  4476.                     || (GetTokenKeywordTag(Token) != eKeywordFreq))
  4477.                     {
  4478.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  4479.                         return eBuildInstrExpectedFreq;
  4480.                     }
  4481.                 Error = ParseNumber(Scanner,ErrorLine,&Number);
  4482.                 if (Error != eBuildInstrNoError)
  4483.                     {
  4484.                         return Error;
  4485.                     }
  4486.                 SetSingleFilterCutoff(FilterElement,Number);
  4487.             }
  4488.  
  4489.         /* <bandwidth>             ::= bandwidth <number>  */
  4490.         /*                         ::= */
  4491.         if ((FilterType == eFilterSecondOrderResonant)
  4492.             || (FilterType == eFilterSecondOrderZero)
  4493.             || (FilterType == eFilterButterworthBandpass)
  4494.             || (FilterType == eFilterButterworthBandreject))
  4495.             {
  4496.                 Token = GetNextToken(Scanner);
  4497.                 if (Token == NIL)
  4498.                     {
  4499.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  4500.                         return eBuildInstrOutOfMemory;
  4501.                     }
  4502.                 if ((GetTokenType(Token) != eTokenKeyword)
  4503.                     || (GetTokenKeywordTag(Token) != eKeywordBandwidth))
  4504.                     {
  4505.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  4506.                         return eBuildInstrExpectedBandwidth;
  4507.                     }
  4508.                 Error = ParseNumber(Scanner,ErrorLine,&Number);
  4509.                 if (Error != eBuildInstrNoError)
  4510.                     {
  4511.                         return Error;
  4512.                     }
  4513.                 SetSingleFilterBandwidth(FilterElement,Number);
  4514.             }
  4515.  
  4516.         /* scaling mode */
  4517.         Token = GetNextToken(Scanner);
  4518.         if (Token == NIL)
  4519.             {
  4520.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4521.                 return eBuildInstrOutOfMemory;
  4522.             }
  4523.         if ((GetTokenType(Token) == eTokenKeyword)
  4524.             && ((GetTokenKeywordTag(Token) == eKeywordDefaultscaling)
  4525.                 || (GetTokenKeywordTag(Token) == eKeywordUnitymidbandgain)
  4526.                 || (GetTokenKeywordTag(Token) == eKeywordUnitynoisegain)
  4527.                 || (GetTokenKeywordTag(Token) == eKeywordUnityzerohertzgain)))
  4528.             {
  4529.                 switch (FilterType)
  4530.                     {
  4531.                         default:
  4532.                             EXECUTE(PRERR(ForceAbort,"ParseFilter:  bad filter type"));
  4533.                             break;
  4534.                         case eFilterNull:
  4535.                         case eFilterFirstOrderLowpass:
  4536.                         case eFilterFirstOrderHighpass:
  4537.                         case eFilterButterworthLowpass:
  4538.                         case eFilterButterworthHighpass:
  4539.                         case eFilterButterworthBandpass:
  4540.                         case eFilterButterworthBandreject:
  4541.                             if (GetTokenKeywordTag(Token) != eKeywordDefaultscaling)
  4542.                                 {
  4543.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  4544.                                     return eBuildInstrExpectedDefaultScaling;
  4545.                                 }
  4546.                             break;
  4547.                         case eFilterSecondOrderResonant:
  4548.                             if (GetTokenKeywordTag(Token) == eKeywordDefaultscaling)
  4549.                                 {
  4550.                                 }
  4551.                             else if (GetTokenKeywordTag(Token) == eKeywordUnitymidbandgain)
  4552.                                 {
  4553.                                     SetSingleFilterScalingMode(FilterElement,eFilterResonMidbandGain1);
  4554.                                 }
  4555.                             else if (GetTokenKeywordTag(Token) == eKeywordUnitynoisegain)
  4556.                                 {
  4557.                                     SetSingleFilterScalingMode(FilterElement,eFilterResonNoiseGain1);
  4558.                                 }
  4559.                             else
  4560.                                 {
  4561.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  4562.                                     return eBuildInstrExpectedResonScaling;
  4563.                                 }
  4564.                             break;
  4565.                         case eFilterSecondOrderZero:
  4566.                             if (GetTokenKeywordTag(Token) == eKeywordDefaultscaling)
  4567.                                 {
  4568.                                 }
  4569.                             else if (GetTokenKeywordTag(Token) == eKeywordUnityzerohertzgain)
  4570.                                 {
  4571.                                     SetSingleFilterScalingMode(FilterElement,eFilterZeroGain1);
  4572.                                 }
  4573.                             else
  4574.                                 {
  4575.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  4576.                                     return eBuildInstrExpectedZeroScaling;
  4577.                                 }
  4578.                             break;
  4579.                     }
  4580.             }
  4581.          else
  4582.             {
  4583.                 UngetToken(Scanner,Token);
  4584.             }
  4585.  
  4586.         /* <channel> ::= {left | right | mono} */
  4587.         Token = GetNextToken(Scanner);
  4588.         if (Token == NIL)
  4589.             {
  4590.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4591.                 return eBuildInstrOutOfMemory;
  4592.             }
  4593.         if (GetTokenType(Token) != eTokenKeyword)
  4594.             {
  4595.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4596.                 return eBuildInstrExpectedFilterChannel;
  4597.             }
  4598.         switch (GetTokenKeywordTag(Token))
  4599.             {
  4600.                 default:
  4601.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  4602.                     return eBuildInstrExpectedFilterChannel;
  4603.                 case eKeywordLeft:
  4604.                     SetSingleFilterChannel(FilterElement,eFilterLeft);
  4605.                     break;
  4606.                 case eKeywordRight:
  4607.                     SetSingleFilterChannel(FilterElement,eFilterRight);
  4608.                     break;
  4609.                 case eKeywordMono:
  4610.                     SetSingleFilterChannel(FilterElement,eFilterBoth);
  4611.                     break;
  4612.             }
  4613.  
  4614.         /* <filterattributes> */
  4615.         OnceOnlyChecker = 0;
  4616.         Error = ParseFilterAttributes(FilterElement,Scanner,ErrorLine,
  4617.             &OnceOnlyChecker,FilterType);
  4618.         if (Error != eBuildInstrNoError)
  4619.             {
  4620.                 return Error;
  4621.             }
  4622.  
  4623.         Token = GetNextToken(Scanner);
  4624.         if (Token == NIL)
  4625.             {
  4626.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4627.                 return eBuildInstrOutOfMemory;
  4628.             }
  4629.         if (GetTokenType(Token) != eTokenSemicolon)
  4630.             {
  4631.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4632.                 return eBuildInstrExpectedSemicolon;
  4633.             }
  4634.  
  4635.         return eBuildInstrNoError;
  4636.     }
  4637.  
  4638.  
  4639.  
  4640.  
  4641. /* XXX:                    ::= <filterattr> <filterattributes> */
  4642. /*                         ::= */
  4643. /* FOLLOW SET: */
  4644. /* { ; } */
  4645. static BuildInstrErrors            ParseFilterAttributes(OneFilterRec* FilterElement,
  4646.                                                             ScannerRec* Scanner, long *ErrorLine,
  4647.                                                             unsigned long* OnceOnlyDefinitions,
  4648.                                                             FilterTypes FilterType)
  4649.     {
  4650.         TokenRec*                                    Token;
  4651.         BuildInstrErrors                    Error;
  4652.  
  4653.         Token = GetNextToken(Scanner);
  4654.         if (Token == NIL)
  4655.             {
  4656.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4657.                 return eBuildInstrOutOfMemory;
  4658.             }
  4659.         if (GetTokenType(Token) == eTokenSemicolon)
  4660.             {
  4661.                 UngetToken(Scanner,Token);
  4662.                 return eBuildInstrNoError;
  4663.             }
  4664.         UngetToken(Scanner,Token);
  4665.  
  4666.         Error = ParseFilterAttr(FilterElement,Scanner,ErrorLine,
  4667.             OnceOnlyDefinitions,FilterType);
  4668.         if (Error != eBuildInstrNoError)
  4669.             {
  4670.                 return Error;
  4671.             }
  4672.  
  4673.         return ParseFilterAttributes(FilterElement,Scanner,ErrorLine,
  4674.             OnceOnlyDefinitions,FilterType);
  4675.     }
  4676.  
  4677.  
  4678.  
  4679.  
  4680. /* XXX:                    ::= freqaccent1 <number> */
  4681. /*                         ::= freqaccent2 <number> */
  4682. /*                         ::= freqaccent3 <number> */
  4683. /*                         ::= freqaccent4 <number> */
  4684. /*                         ::= bandwidthaccent1 <number> */
  4685. /*                         ::= bandwidthaccent2 <number> */
  4686. /*                         ::= bandwidthaccent3 <number> */
  4687. /*                         ::= bandwidthaccent4 <number> */
  4688. /*                         ::= outputscaling <number> */
  4689. /*                         ::= outputscalingaccent1 <number> */
  4690. /*                         ::= outputscalingaccent2 <number> */
  4691. /*                         ::= outputscalingaccent3 <number> */
  4692. /*                         ::= outputscalingaccent4 <number> */
  4693. static BuildInstrErrors            ParseFilterAttr(OneFilterRec* FilterElement,
  4694.                                                             ScannerRec* Scanner, long *ErrorLine,
  4695.                                                             unsigned long* OnceOnlyDefinitions,
  4696.                                                             FilterTypes FilterType)
  4697.     {
  4698.         TokenRec*                                    Token;
  4699.         BuildInstrErrors                    Error;
  4700.         double                                        Number;
  4701.  
  4702.         Token = GetNextToken(Scanner);
  4703.         if (Token == NIL)
  4704.             {
  4705.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4706.                 return eBuildInstrOutOfMemory;
  4707.             }
  4708.         if (GetTokenType(Token) != eTokenKeyword)
  4709.             {
  4710.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  4711.                 return eBuildInstrExpectedFilterAttr;
  4712.             }
  4713.         switch (GetTokenKeywordTag(Token))
  4714.             {
  4715.                 default:
  4716.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  4717.                     return eBuildInstrExpectedFilterAttr;
  4718.                 case eKeywordFreqaccent1:
  4719.                     if (FilterType == eFilterNull)
  4720.                         {
  4721.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4722.                             return eBuildInstrNullFilterHasNoFreqAccent1;
  4723.                         }
  4724.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_FREQACCENT1) != 0)
  4725.                         {
  4726.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4727.                             return eBuildInstrMultipleFreqaccent1;
  4728.                         }
  4729.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4730.                     if (Error != eBuildInstrNoError)
  4731.                         {
  4732.                             return Error;
  4733.                         }
  4734.                     SetSingleFilterCutoffAccent1(FilterElement,Number);
  4735.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_FREQACCENT1;
  4736.                     break;
  4737.                 case eKeywordFreqaccent2:
  4738.                     if (FilterType == eFilterNull)
  4739.                         {
  4740.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4741.                             return eBuildInstrNullFilterHasNoFreqAccent2;
  4742.                         }
  4743.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_FREQACCENT2) != 0)
  4744.                         {
  4745.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4746.                             return eBuildInstrMultipleFreqaccent2;
  4747.                         }
  4748.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4749.                     if (Error != eBuildInstrNoError)
  4750.                         {
  4751.                             return Error;
  4752.                         }
  4753.                     SetSingleFilterCutoffAccent2(FilterElement,Number);
  4754.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_FREQACCENT2;
  4755.                     break;
  4756.                 case eKeywordFreqaccent3:
  4757.                     if (FilterType == eFilterNull)
  4758.                         {
  4759.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4760.                             return eBuildInstrNullFilterHasNoFreqAccent3;
  4761.                         }
  4762.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_FREQACCENT3) != 0)
  4763.                         {
  4764.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4765.                             return eBuildInstrMultipleFreqaccent3;
  4766.                         }
  4767.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4768.                     if (Error != eBuildInstrNoError)
  4769.                         {
  4770.                             return Error;
  4771.                         }
  4772.                     SetSingleFilterCutoffAccent3(FilterElement,Number);
  4773.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_FREQACCENT3;
  4774.                     break;
  4775.                 case eKeywordFreqaccent4:
  4776.                     if (FilterType == eFilterNull)
  4777.                         {
  4778.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4779.                             return eBuildInstrNullFilterHasNoFreqAccent4;
  4780.                         }
  4781.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_FREQACCENT4) != 0)
  4782.                         {
  4783.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4784.                             return eBuildInstrMultipleFreqaccent4;
  4785.                         }
  4786.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4787.                     if (Error != eBuildInstrNoError)
  4788.                         {
  4789.                             return Error;
  4790.                         }
  4791.                     SetSingleFilterCutoffAccent4(FilterElement,Number);
  4792.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_FREQACCENT4;
  4793.                     break;
  4794.                 case eKeywordBandwidthaccent1:
  4795.                     if ((FilterType != eFilterSecondOrderResonant)
  4796.                         && (FilterType != eFilterSecondOrderZero)
  4797.                         && (FilterType != eFilterButterworthBandpass)
  4798.                         && (FilterType != eFilterButterworthBandreject))
  4799.                         {
  4800.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4801.                             return eBuildInstrFilterHasNoBandwidthAccent1;
  4802.                         }
  4803.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT1) != 0)
  4804.                         {
  4805.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4806.                             return eBuildInstrMultipleBandwidthaccent1;
  4807.                         }
  4808.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4809.                     if (Error != eBuildInstrNoError)
  4810.                         {
  4811.                             return Error;
  4812.                         }
  4813.                     SetSingleFilterBandwidthAccent1(FilterElement,Number);
  4814.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT1;
  4815.                     break;
  4816.                 case eKeywordBandwidthaccent2:
  4817.                     if ((FilterType != eFilterSecondOrderResonant)
  4818.                         && (FilterType != eFilterSecondOrderZero)
  4819.                         && (FilterType != eFilterButterworthBandpass)
  4820.                         && (FilterType != eFilterButterworthBandreject))
  4821.                         {
  4822.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4823.                             return eBuildInstrFilterHasNoBandwidthAccent2;
  4824.                         }
  4825.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT2) != 0)
  4826.                         {
  4827.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4828.                             return eBuildInstrMultipleBandwidthaccent2;
  4829.                         }
  4830.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4831.                     if (Error != eBuildInstrNoError)
  4832.                         {
  4833.                             return Error;
  4834.                         }
  4835.                     SetSingleFilterBandwidthAccent2(FilterElement,Number);
  4836.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT2;
  4837.                     break;
  4838.                 case eKeywordBandwidthaccent3:
  4839.                     if ((FilterType != eFilterSecondOrderResonant)
  4840.                         && (FilterType != eFilterSecondOrderZero)
  4841.                         && (FilterType != eFilterButterworthBandpass)
  4842.                         && (FilterType != eFilterButterworthBandreject))
  4843.                         {
  4844.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4845.                             return eBuildInstrFilterHasNoBandwidthAccent3;
  4846.                         }
  4847.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT3) != 0)
  4848.                         {
  4849.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4850.                             return eBuildInstrMultipleBandwidthaccent3;
  4851.                         }
  4852.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4853.                     if (Error != eBuildInstrNoError)
  4854.                         {
  4855.                             return Error;
  4856.                         }
  4857.                     SetSingleFilterBandwidthAccent3(FilterElement,Number);
  4858.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT3;
  4859.                     break;
  4860.                 case eKeywordBandwidthaccent4:
  4861.                     if ((FilterType != eFilterSecondOrderResonant)
  4862.                         && (FilterType != eFilterSecondOrderZero)
  4863.                         && (FilterType != eFilterButterworthBandpass)
  4864.                         && (FilterType != eFilterButterworthBandreject))
  4865.                         {
  4866.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4867.                             return eBuildInstrFilterHasNoBandwidthAccent4;
  4868.                         }
  4869.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT4) != 0)
  4870.                         {
  4871.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4872.                             return eBuildInstrMultipleBandwidthaccent4;
  4873.                         }
  4874.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4875.                     if (Error != eBuildInstrNoError)
  4876.                         {
  4877.                             return Error;
  4878.                         }
  4879.                     SetSingleFilterBandwidthAccent4(FilterElement,Number);
  4880.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_BANDWIDTHACCENT4;
  4881.                     break;
  4882.                 case eKeywordOutputscaling:
  4883.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALING) != 0)
  4884.                         {
  4885.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4886.                             return eBuildInstrMultipleOutputScaling;
  4887.                         }
  4888.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4889.                     if (Error != eBuildInstrNoError)
  4890.                         {
  4891.                             return Error;
  4892.                         }
  4893.                     SetSingleFilterOutputMultiplier(FilterElement,Number);
  4894.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALING;
  4895.                     break;
  4896.                 case eKeywordOutputaccent1:
  4897.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT1) != 0)
  4898.                         {
  4899.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4900.                             return eBuildInstrMultipleOutputScalingAccent1;
  4901.                         }
  4902.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4903.                     if (Error != eBuildInstrNoError)
  4904.                         {
  4905.                             return Error;
  4906.                         }
  4907.                     SetSingleFilterOutputMultiplierAccent1(FilterElement,Number);
  4908.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT1;
  4909.                     break;
  4910.                 case eKeywordOutputaccent2:
  4911.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT2) != 0)
  4912.                         {
  4913.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4914.                             return eBuildInstrMultipleOutputScalingAccent2;
  4915.                         }
  4916.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4917.                     if (Error != eBuildInstrNoError)
  4918.                         {
  4919.                             return Error;
  4920.                         }
  4921.                     SetSingleFilterOutputMultiplierAccent2(FilterElement,Number);
  4922.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT2;
  4923.                     break;
  4924.                 case eKeywordOutputaccent3:
  4925.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT3) != 0)
  4926.                         {
  4927.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4928.                             return eBuildInstrMultipleOutputScalingAccent3;
  4929.                         }
  4930.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4931.                     if (Error != eBuildInstrNoError)
  4932.                         {
  4933.                             return Error;
  4934.                         }
  4935.                     SetSingleFilterOutputMultiplierAccent3(FilterElement,Number);
  4936.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT3;
  4937.                     break;
  4938.                 case eKeywordOutputaccent4:
  4939.                     if ((*OnceOnlyDefinitions & FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT4) != 0)
  4940.                         {
  4941.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  4942.                             return eBuildInstrMultipleOutputScalingAccent4;
  4943.                         }
  4944.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  4945.                     if (Error != eBuildInstrNoError)
  4946.                         {
  4947.                             return Error;
  4948.                         }
  4949.                     SetSingleFilterOutputMultiplierAccent4(FilterElement,Number);
  4950.                     *OnceOnlyDefinitions |= FILTEREFFECTATTR_ONCEONLY_OUTPUTSCALINGACCENT4;
  4951.                     break;
  4952.             }
  4953.  
  4954.         return eBuildInstrNoError;
  4955.     }
  4956.  
  4957.  
  4958.  
  4959.  
  4960. /* build just a list of effects */
  4961. BuildInstrErrors                        BuildEffectList(char* TextFile, long* ErrorLine,
  4962.                                                             struct EffectSpecListRec** EffectOut,
  4963.                                                             struct WaveTableListRec* WaveTableList,
  4964.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  4965.     {
  4966.         TrashTrackRec*                        TrashTracker;
  4967.         ScannerRec*                                Scanner;
  4968.         EffectSpecListRec*                EffectSpec;
  4969.         BuildInstrErrors                    Error;
  4970.         TokenRec*                                    Token;
  4971.  
  4972.         CheckPtrExistence(TextFile);
  4973.         CheckPtrExistence(WaveTableList);
  4974.         CheckPtrExistence(AlgoWaveTableList);
  4975.         EXECUTE(*EffectOut = (EffectSpecListRec*)0x81818181;)
  4976.         EXECUTE(*ErrorLine = 0x81818181;)
  4977.  
  4978.         TrashTracker = NewTrashTracker();
  4979.         if (TrashTracker == NIL)
  4980.             {
  4981.              NoMemoryFailurePoint1:
  4982.                 *ErrorLine = 1;
  4983.                 return eBuildInstrOutOfMemory;
  4984.             }
  4985.  
  4986.         Scanner = NewScanner(TrashTracker,TextFile);
  4987.         if (Scanner == NIL)
  4988.             {
  4989.              NoMemoryFailurePoint2:
  4990.                 goto NoMemoryFailurePoint1;
  4991.             }
  4992.  
  4993.         EffectSpec = NewEffectSpecList();
  4994.         if (EffectSpec == NIL)
  4995.             {
  4996.              NoMemoryFailurePoint3:
  4997.                 goto NoMemoryFailurePoint2;
  4998.             }
  4999.  
  5000.         LoadScannerKeywords(Scanner);
  5001.  
  5002.         do
  5003.             {
  5004.                 Token = GetNextToken(Scanner);
  5005.                 if (Token == NIL)
  5006.                     {
  5007.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  5008.                         DisposeTrashTracker(TrashTracker);
  5009.                         DisposeEffectSpecList(EffectSpec);
  5010.                         return eBuildInstrOutOfMemory;
  5011.                     }
  5012.                 if (GetTokenType(Token) != eTokenEndOfInput)
  5013.                     {
  5014.                         if ((GetTokenType(Token) != eTokenKeyword)
  5015.                             || (GetTokenKeywordTag(Token) != eKeywordScoreeffect))
  5016.                             {
  5017.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  5018.                                 DisposeTrashTracker(TrashTracker);
  5019.                                 DisposeEffectSpecList(EffectSpec);
  5020.                                 return eBuildInstrExpectedScoreEffect;
  5021.                             }
  5022.                         Error = ParseTrackEffect(EffectSpec,Scanner,ErrorLine,
  5023.                             WaveTableList,AlgoWaveTableList);
  5024.                         if (Error != eBuildInstrNoError)
  5025.                             {
  5026.                                 DisposeTrashTracker(TrashTracker);
  5027.                                 DisposeEffectSpecList(EffectSpec);
  5028.                                 return Error;
  5029.                             }
  5030.                         Token = GetNextToken(Scanner);
  5031.                         if (Token == NIL)
  5032.                             {
  5033.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  5034.                                 DisposeTrashTracker(TrashTracker);
  5035.                                 DisposeEffectSpecList(EffectSpec);
  5036.                                 return eBuildInstrOutOfMemory;
  5037.                             }
  5038.                         if (GetTokenType(Token) != eTokenSemicolon)
  5039.                             {
  5040.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  5041.                                 DisposeTrashTracker(TrashTracker);
  5042.                                 DisposeEffectSpecList(EffectSpec);
  5043.                                 return eBuildInstrExpectedSemicolon;
  5044.                             }
  5045.                     }
  5046.             } while (GetTokenType(Token) != eTokenEndOfInput);
  5047.  
  5048.         *EffectOut = EffectSpec;
  5049.         DisposeTrashTracker(TrashTracker);
  5050.         return eBuildInstrNoError;
  5051.     }
  5052.  
  5053.  
  5054.  
  5055.  
  5056. /* get a static null terminated string describing the error */
  5057. char*                                                BuildInstrGetErrorMessageText(BuildInstrErrors ErrorCode)
  5058.     {
  5059.         char*                                            S EXECUTE(= (char*)0x81818181);
  5060.  
  5061.         switch (ErrorCode)
  5062.             {
  5063.                 default:
  5064.                     EXECUTE(PRERR(ForceAbort,"BuildInstrGetErrorMessageText:  bad error code"));
  5065.                     break;
  5066.                 case eBuildInstrOutOfMemory:
  5067.                     S = "Out of memory";
  5068.                     break;
  5069.                 case eBuildInstrUnexpectedInput:
  5070.                     S = "Unexpected end of text";
  5071.                     break;
  5072.                 case eBuildInstrExpectedInstrument:
  5073.                     S = "Expected 'instrument'";
  5074.                     break;
  5075.                 case eBuildInstrExpectedOpenParen:
  5076.                     S = "Expected '"OPAREN"'";
  5077.                     break;
  5078.                 case eBuildInstrExpectedCloseParen:
  5079.                     S = "Expected '"CPAREN"'";
  5080.                     break;
  5081.                 case eBuildInstrSomeRequiredInstrParamsMissing:
  5082.                     S = "Some required instrument parameters have not been specified";
  5083.                     break;
  5084.                 case eBuildInstrExpectedSemicolon:
  5085.                     S = "Expected ';'";
  5086.                     break;
  5087.                 case eBuildInstrExpectedInstrumentMember:
  5088.                     S = "Expected 'loudness', 'frequencylfo', 'oscillator', or 'trackeffect'";
  5089.                     break;
  5090.                 case eBuildInstrMultipleInstrLoudness:
  5091.                     S = "Instrument parameter 'loudness' has already been specified";
  5092.                     break;
  5093.                 case eBuildInstrSomeRequiredLFOParamsMissing:
  5094.                     S = "Some required LFO parameters have not been specified";
  5095.                     break;
  5096.                 case eBuildInstrSomeRequiredOscillatorParamsMissing:
  5097.                     S = "Some required oscillator parameters have not been specified";
  5098.                     break;
  5099.                 case eBuildInstrExpectedNumber:
  5100.                     S = "Expected a number";
  5101.                     break;
  5102.                 case eBuildInstrExpectedStringOrIdentifier:
  5103.                     S = "Expected a string or identifier";
  5104.                     break;
  5105.                 case eBuildInstrExpectedLFOMember:
  5106.                     S = "Expected 'freqenvelope', 'ampenvelope', 'oscillator', 'modulation', "
  5107.                         "'linear', or 'exponential'";
  5108.                     break;
  5109.                 case eBuildInstrMultipleLFOFreqEnvelope:
  5110.                     S = "LFO parameter 'freqenvelope' has already been specified";
  5111.                     break;
  5112.                 case eBuildInstrSomeRequiredEnvelopeParamsMissing:
  5113.                     S = "Some required envelope parameters have not been specified";
  5114.                     break;
  5115.                 case eBuildInstrMultipleLFOAmpEnvelope:
  5116.                     S = "LFO parameter 'ampenvelope' has already been specified";
  5117.                     break;
  5118.                 case eBuildInstrMultipleLFOOscillatorType:
  5119.                     S = "LFO parameter 'oscillator' has already been specified";
  5120.                     break;
  5121.                 case eBuildInstrExpectedLFOOscillatorType:
  5122.                     S = "Expected 'constant', 'signsine', 'plussine', 'signtriangle', "
  5123.                         "'plustriangle', 'signsquare', 'plussquare', 'signramp', 'plusramp', "
  5124.                         "'signlinfuzz', 'pluslinfuzz', or 'wavetable'";
  5125.                     break;
  5126.                 case eBuildInstrMultipleLFOModulationType:
  5127.                     S = "LFO parameter 'modulation' has already been specified";
  5128.                     break;
  5129.                 case eBuildInstrMultipleLFOAddingMode:
  5130.                     S = "LFO adding mode ('linear' or 'exponential') has already been specified";
  5131.                     break;
  5132.                 case eBuildInstrExpectedLFOModulationType:
  5133.                     S = "Expected 'additive', 'multiplicative', or 'inversemult'";
  5134.                     break;
  5135.                 case eBuildInstrExpectedOscillatorMember:
  5136.                     S = "Expected 'type', 'samplelist', 'loudness', "
  5137.                         "'freqmultiplier', 'freqdivisor', 'freqadder', "
  5138.                         "'loudnessenvelope', 'loudnesslfo', 'indexenvelope', 'indexlfo', "
  5139.                         "'stereobias', 'displacement', or 'frequencylfo'";
  5140.                     break;
  5141.                 case eBuildInstrMultipleOscType:
  5142.                     S = "Oscillator parameter 'type' has already been specified";
  5143.                     break;
  5144.                 case eBuildInstrMultipleOscSampleList:
  5145.                     S = "Oscillator parameter 'samplelist' has already been specified";
  5146.                     break;
  5147.                 case eBuildInstrMultipleOscLoudness:
  5148.                     S = "Oscillator parameter 'loudness' has already been specified";
  5149.                     break;
  5150.                 case eBuildInstrMultipleOscFreqMultiplier:
  5151.                     S = "Oscillator parameter 'freqmultiplier' has already been specified";
  5152.                     break;
  5153.                 case eBuildInstrMultipleOscFreqDivisor:
  5154.                     S = "Oscillator parameter 'freqdivisor' has already been specified";
  5155.                     break;
  5156.                 case eBuildInstrMultipleOscLoudnessEnvelope:
  5157.                     S = "Oscillator parameter 'loudnessenvelope' has already been specified";
  5158.                     break;
  5159.                 case eBuildInstrMultipleOscIndexEnvelope:
  5160.                     S = "Oscillator parameter 'indexenvelope' has already been specified";
  5161.                     break;
  5162.                 case eBuildInstrExpectedOscType:
  5163.                     S = "Expected 'sampled' or 'wavetable'";
  5164.                     break;
  5165.                 case eBuildInstrExpectedInteger:
  5166.                     S = "Expected an integer";
  5167.                     break;
  5168.                 case eBuildInstrExpectedEnvelopeMember:
  5169.                     S = "Expected 'totalscaling' or 'points'";
  5170.                     break;
  5171.                 case eBuildInstrMultipleEnvTotalScaling:
  5172.                     S = "Envelope parameter 'totalscaling' has already been specified";
  5173.                     break;
  5174.                 case eBuildInstrMultipleEnvPoints:
  5175.                     S = "Envelope parameter 'points' has already been specified";
  5176.                     break;
  5177.                 case eBuildInstrExpectedDelayOrOrigin:
  5178.                     S = "Expected 'delay' or 'origin'";
  5179.                     break;
  5180.                 case eBuildInstrExpectedLevelOrScale:
  5181.                     S = "Expected 'level' or 'scale'";
  5182.                     break;
  5183.                 case eBuildInstrExpectedEnvPointMember:
  5184.                     S = "Expected 'sustainpoint', 'sustainpointnoskip', 'releasepoint', "
  5185.                         "'releasepointnoskip', 'ampaccent1', 'ampaccent2', 'ampaccent3', "
  5186.                         "'ampaccent4', 'ampfreq', 'rateaccent1', 'rateaccent2', 'rateaccent3', "
  5187.                         "'rateaccent4', 'ratefreq', 'exponential', or 'linear'";
  5188.                     break;
  5189.                 case eBuildInstrExpectedIntBetween1And3:
  5190.                     S = "Expected an integer in the range [1..3]";
  5191.                     break;
  5192.                 case eBuildInstrEnvSustainPointAlreadyDefined:
  5193.                     S = "That envelope sustain point has already been specified";
  5194.                     break;
  5195.                 case eBuildInstrMultipleEnvPointAmpAccent1:
  5196.                     S = "Envelope parameter 'ampaccent1' has already been specified";
  5197.                     break;
  5198.                 case eBuildInstrMultipleEnvPointAmpAccent2:
  5199.                     S = "Envelope parameter 'ampaccent2' has already been specified";
  5200.                     break;
  5201.                 case eBuildInstrMultipleEnvPointAmpAccent3:
  5202.                     S = "Envelope parameter 'ampaccent3' has already been specified";
  5203.                     break;
  5204.                 case eBuildInstrMultipleEnvPointAmpAccent4:
  5205.                     S = "Envelope parameter 'ampaccent4' has already been specified";
  5206.                     break;
  5207.                 case eBuildInstrMultipleEnvPointAmpFreq:
  5208.                     S = "Envelope parameter 'ampfreq' has already been specified";
  5209.                     break;
  5210.                 case eBuildInstrMultipleEnvPointRateAccent1:
  5211.                     S = "Envelope parameter 'rateaccent1' has already been specified";
  5212.                     break;
  5213.                 case eBuildInstrMultipleEnvPointRateAccent2:
  5214.                     S = "Envelope parameter 'rateaccent2' has already been specified";
  5215.                     break;
  5216.                 case eBuildInstrMultipleEnvPointRateAccent3:
  5217.                     S = "Envelope parameter 'rateaccent3' has already been specified";
  5218.                     break;
  5219.                 case eBuildInstrMultipleEnvPointRateAccent4:
  5220.                     S = "Envelope parameter 'rateaccent4' has already been specified";
  5221.                     break;
  5222.                 case eBuildInstrMultipleEnvPointRateFreq:
  5223.                     S = "Envelope parameter 'ratefreq' has already been specified";
  5224.                     break;
  5225.                 case eBuildInstrMultipleEnvPointCurveSpec:
  5226.                     S = "Envelope parameter 'exponential' or 'linear' has "
  5227.                         "already been specified";
  5228.                     break;
  5229.                 case eBuildInstrSomeSamplesDontExist:
  5230.                     S = "Some named samples or algorithmic samples do not exist";
  5231.                     break;
  5232.                 case eBuildInstrSomeWaveTablesDontExist:
  5233.                     S = "Some named wave tables or algorithmic wave tables do not exist";
  5234.                     break;
  5235.                 case eBuildInstrMultipleOscStereoBias:
  5236.                     S = "Oscillator parameter 'stereobias' has already been specified";
  5237.                     break;
  5238.                 case eBuildInstrMultipleOscDisplacement:
  5239.                     S = "Oscillator parameter 'displacement' has already been specified";
  5240.                     break;
  5241.                 case eBuildInstrMultipleOscSurroundBias:
  5242.                     S = "Oscillator parameter 'surroundbias' has already been specified";
  5243.                     break;
  5244.                 case eBuildInstrMultipleOscFreqAdder:
  5245.                     S = "Oscillator parameter 'freqadder' has already been specified";
  5246.                     break;
  5247.                 case eBuildInstrExpectedSquareOrTriangle:
  5248.                     S = "Expected 'square' or 'triangle'";
  5249.                     break;
  5250.                 case eBuildInstrExpectedEffectName:
  5251.                     S = "Expected 'delayline', 'nlproc', 'filter', or 'analyzer'";
  5252.                     break;
  5253.                 case eBuildInstrExpectedDelayLineElem:
  5254.                     S = "Expected 'tap' or 'maxdelaytime'";
  5255.                     break;
  5256.                 case eBuildInstrExpectedTapChannel:
  5257.                     S = "Expected 'left', 'right', or 'mono'";
  5258.                     break;
  5259.                 case eBuildInstrExpectedTo:
  5260.                     S = "Expected 'to'";
  5261.                     break;
  5262.                 case eBuildInstrExpectedScale:
  5263.                     S = "Expected 'scale'";
  5264.                     break;
  5265.                 case eBuildInstrExpectedTapAttr:
  5266.                     S = "Expected 'sourceaccent1', 'sourceaccent2', 'sourceaccent3', "
  5267.                         "'sourceaccent4', 'targetaccent1', 'targetaccent2', 'targetaccent3', "
  5268.                         "'targetaccent4', 'scaleaccent1', 'scaleaccent2', 'scaleaccent3', "
  5269.                         "'scaleaccent4', or 'movingaveragelowpass'";
  5270.                     break;
  5271.                 case eBuildInstrMultipleSourceAccent1:
  5272.                     S = "Delay tap parameter 'sourceaccent1' has already been specified";
  5273.                     break;
  5274.                 case eBuildInstrMultipleSourceAccent2:
  5275.                     S = "Delay tap parameter 'sourceaccent2' has already been specified";
  5276.                     break;
  5277.                 case eBuildInstrMultipleSourceAccent3:
  5278.                     S = "Delay tap parameter 'sourceaccent3' has already been specified";
  5279.                     break;
  5280.                 case eBuildInstrMultipleSourceAccent4:
  5281.                     S = "Delay tap parameter 'sourceaccent4' has already been specified";
  5282.                     break;
  5283.                 case eBuildInstrMultipleTargetAccent1:
  5284.                     S = "Delay tap parameter 'targetaccent1' has already been specified";
  5285.                     break;
  5286.                 case eBuildInstrMultipleTargetAccent2:
  5287.                     S = "Delay tap parameter 'targetaccent2' has already been specified";
  5288.                     break;
  5289.                 case eBuildInstrMultipleTargetAccent3:
  5290.                     S = "Delay tap parameter 'targetaccent3' has already been specified";
  5291.                     break;
  5292.                 case eBuildInstrMultipleTargetAccent4:
  5293.                     S = "Delay tap parameter 'targetaccent4' has already been specified";
  5294.                     break;
  5295.                 case eBuildInstrMultipleScaleAccent1:
  5296.                     S = "Delay tap parameter 'scaleaccent1' has already been specified";
  5297.                     break;
  5298.                 case eBuildInstrMultipleScaleAccent2:
  5299.                     S = "Delay tap parameter 'scaleaccent2' has already been specified";
  5300.                     break;
  5301.                 case eBuildInstrMultipleScaleAccent3:
  5302.                     S = "Delay tap parameter 'scaleaccent3' has already been specified";
  5303.                     break;
  5304.                 case eBuildInstrMultipleScaleAccent4:
  5305.                     S = "Delay tap parameter 'scaleaccent4' has already been specified";
  5306.                     break;
  5307.                 case eBuildInstrMultipleFilter:
  5308.                     S = "Delay tap filter has already been specified";
  5309.                     break;
  5310.                 case eBuildInstrMultipleMaxDelayTime:
  5311.                     S = "Delay line parameter 'maxdelaytime' has already been specified";
  5312.                     break;
  5313.                 case eBuildInstrExpectedSlope:
  5314.                     S = "Expected 'slope'";
  5315.                     break;
  5316.                 case eBuildInstrExpectedCenter:
  5317.                     S = "Expected 'center'";
  5318.                     break;
  5319.                 case eBuildInstrExpectedSamplelist:
  5320.                     S = "Expected 'samplelist'";
  5321.                     break;
  5322.                 case eBuildInstrExpectedEnvelope:
  5323.                     S = "Expected 'envelope'";
  5324.                     break;
  5325.                 case eBuildInstrExpectedWavetable:
  5326.                     S = "Expected 'wavetable'";
  5327.                     break;
  5328.                 case eBuildInstrUndefinedWavetable:
  5329.                     S = "Specified wavetable does not exist";
  5330.                     break;
  5331.                 case eBuildInstrExpectedInputscaling:
  5332.                     S = "Expected 'inputscaling'";
  5333.                     break;
  5334.                 case eBuildInstrExpectedOutputscaling:
  5335.                     S = "Expected 'outputscaling'";
  5336.                     break;
  5337.                 case eBuildInstrExpectedNLAttribute:
  5338.                     S = "Expected 'inputaccent1', 'inputaccent2', 'inputaccent3', "
  5339.                         "'inputaccent4', 'outputaccent1', 'outputaccent2', 'outputaccent3', "
  5340.                         "'outputaccent4', 'indexaccent1', 'indexaccent2', 'indexaccent3', "
  5341.                         "or 'indexaccent4'";
  5342.                     break;
  5343.                 case eBuildInstrMultipleInputaccent1:
  5344.                     S = "Nonlinear processor parameter 'inputaccent1' has already been specified";
  5345.                     break;
  5346.                 case eBuildInstrMultipleInputaccent2:
  5347.                     S = "Nonlinear processor parameter 'inputaccent2' has already been specified";
  5348.                     break;
  5349.                 case eBuildInstrMultipleInputaccent3:
  5350.                     S = "Nonlinear processor parameter 'inputaccent3' has already been specified";
  5351.                     break;
  5352.                 case eBuildInstrMultipleInputaccent4:
  5353.                     S = "Nonlinear processor parameter 'inputaccent4' has already been specified";
  5354.                     break;
  5355.                 case eBuildInstrMultipleOutputaccent1:
  5356.                     S = "Nonlinear processor parameter 'outputaccent1' has already been specified";
  5357.                     break;
  5358.                 case eBuildInstrMultipleOutputaccent2:
  5359.                     S = "Nonlinear processor parameter 'outputaccent2' has already been specified";
  5360.                     break;
  5361.                 case eBuildInstrMultipleOutputaccent3:
  5362.                     S = "Nonlinear processor parameter 'outputaccent3' has already been specified";
  5363.                     break;
  5364.                 case eBuildInstrMultipleOutputaccent4:
  5365.                     S = "Nonlinear processor parameter 'outputaccent4' has already been specified";
  5366.                     break;
  5367.                 case eBuildInstrMultipleIndexaccent1:
  5368.                     S = "Nonlinear processor parameter 'indexaccent1' has already been specified";
  5369.                     break;
  5370.                 case eBuildInstrMultipleIndexaccent2:
  5371.                     S = "Nonlinear processor parameter 'indexaccent2' has already been specified";
  5372.                     break;
  5373.                 case eBuildInstrMultipleIndexaccent3:
  5374.                     S = "Nonlinear processor parameter 'indexaccent3' has already been specified";
  5375.                     break;
  5376.                 case eBuildInstrMultipleIndexaccent4:
  5377.                     S = "Nonlinear processor parameter 'indexaccent4' has already been specified";
  5378.                     break;
  5379.                 case eBuildInstrExpectedWavetableindex:
  5380.                     S = "Expected 'wavetableindex'";
  5381.                     break;
  5382.                 case eBuildInstrExpectedFilterType:
  5383.                     S = "Expected 'lowpass', 'highpass', 'reson', 'zero', 'butterworthlowpass', "
  5384.                         "'butterworthhighpass', 'butterworthbandpass', or 'butterworthbandreject'";
  5385.                     break;
  5386.                 case eBuildInstrExpectedFreq:
  5387.                     S = "Expected 'freq'";
  5388.                     break;
  5389.                 case eBuildInstrExpectedBandwidth:
  5390.                     S = "Expected 'bandwidth'";
  5391.                     break;
  5392.                 case eBuildInstrExpectedDefaultScaling:
  5393.                     S = "Expected 'defaultscaling'";
  5394.                     break;
  5395.                 case eBuildInstrExpectedResonScaling:
  5396.                     S = "Expected 'defaultscaling', 'unitymidbandgain', or 'unitynoisegain'";
  5397.                     break;
  5398.                 case eBuildInstrExpectedZeroScaling:
  5399.                     S = "Expected 'defaultscaling' or 'unityzerohertzgain'";
  5400.                     break;
  5401.                 case eBuildInstrExpectedFilterAttr:
  5402.                     S = "Expected 'freqaccent1', 'freqaccent2', 'freqaccent3', 'freqaccent4', "
  5403.                         " 'bandwidthaccent1', 'bandwidthaccent2', 'bandwidthaccent3', "
  5404.                         " 'bandwidthaccent4', 'outputscaling', 'outputaccent1', 'outputaccent2', "
  5405.                         " 'outputaccent3', or 'outputaccent4'";
  5406.                     break;
  5407.                 case eBuildInstrMultipleFreqaccent1:
  5408.                     S = "Filter parameter 'freqaccent1' has already been specified";
  5409.                     break;
  5410.                 case eBuildInstrMultipleFreqaccent2:
  5411.                     S = "Filter parameter 'freqaccent2' has already been specified";
  5412.                     break;
  5413.                 case eBuildInstrMultipleFreqaccent3:
  5414.                     S = "Filter parameter 'freqaccent3' has already been specified";
  5415.                     break;
  5416.                 case eBuildInstrMultipleFreqaccent4:
  5417.                     S = "Filter parameter 'freqaccent4' has already been specified";
  5418.                     break;
  5419.                 case eBuildInstrMultipleBandwidthaccent1:
  5420.                     S = "Filter parameter 'bandwidthaccent1' has already been specified";
  5421.                     break;
  5422.                 case eBuildInstrMultipleBandwidthaccent2:
  5423.                     S = "Filter parameter 'bandwidthaccent2' has already been specified";
  5424.                     break;
  5425.                 case eBuildInstrMultipleBandwidthaccent3:
  5426.                     S = "Filter parameter 'bandwidthaccent3' has already been specified";
  5427.                     break;
  5428.                 case eBuildInstrMultipleBandwidthaccent4:
  5429.                     S = "Filter parameter 'bandwidthaccent4' has already been specified";
  5430.                     break;
  5431.                 case eBuildInstrMultipleOutputScaling:
  5432.                     S = "Filter parameter 'outputscaling' has already been specified";
  5433.                     break;
  5434.                 case eBuildInstrMultipleOutputScalingAccent1:
  5435.                     S = "Filter parameter 'outputaccent1' has already been specified";
  5436.                     break;
  5437.                 case eBuildInstrMultipleOutputScalingAccent2:
  5438.                     S = "Filter parameter 'outputaccent2' has already been specified";
  5439.                     break;
  5440.                 case eBuildInstrMultipleOutputScalingAccent3:
  5441.                     S = "Filter parameter 'outputaccent3' has already been specified";
  5442.                     break;
  5443.                 case eBuildInstrMultipleOutputScalingAccent4:
  5444.                     S = "Filter parameter 'outputaccent4' has already been specified";
  5445.                     break;
  5446.                 case eBuildInstrExpectedFilterChannel:
  5447.                     S = "Expected 'left', 'right', 'mono', 'defaultscaling', "
  5448.                         "'unitymidbandgain', 'unitynoisegain', or 'unityzerohertzgain'";
  5449.                     break;
  5450.                 case eBuildInstrNullFilterHasNoFreqAccent1:
  5451.                     S = "Parameter 'freqaccent1' can't be specified for null filter";
  5452.                     break;
  5453.                 case eBuildInstrNullFilterHasNoFreqAccent2:
  5454.                     S = "Parameter 'freqaccent2' can't be specified for null filter";
  5455.                     break;
  5456.                 case eBuildInstrNullFilterHasNoFreqAccent3:
  5457.                     S = "Parameter 'freqaccent3' can't be specified for null filter";
  5458.                     break;
  5459.                 case eBuildInstrNullFilterHasNoFreqAccent4:
  5460.                     S = "Parameter 'freqaccent4' can't be specified for null filter";
  5461.                     break;
  5462.                 case eBuildInstrFilterHasNoBandwidthAccent1:
  5463.                     S = "Parameter 'bandwidthaccent1' can only be specified for filters "
  5464.                         "'reson', 'zero', 'butterworthbandpass', and 'butterworthbandreject'";
  5465.                     break;
  5466.                 case eBuildInstrFilterHasNoBandwidthAccent2:
  5467.                     S = "Parameter 'bandwidthaccent2' can only be specified for filters "
  5468.                         "'reson', 'zero', 'butterworthbandpass', and 'butterworthbandreject'";
  5469.                     break;
  5470.                 case eBuildInstrFilterHasNoBandwidthAccent3:
  5471.                     S = "Parameter 'bandwidthaccent3' can only be specified for filters "
  5472.                         "'reson', 'zero', 'butterworthbandpass', and 'butterworthbandreject'";
  5473.                     break;
  5474.                 case eBuildInstrFilterHasNoBandwidthAccent4:
  5475.                     S = "Parameter 'bandwidthaccent4' can only be specified for filters "
  5476.                         "'reson', 'zero', 'butterworthbandpass', and 'butterworthbandreject'";
  5477.                     break;
  5478.                 case eBuildInstrExpectedScoreEffect:
  5479.                     S = "Expected 'scoreeffect'";
  5480.                     break;
  5481.                 case eBuildInstrExpectedOscillatorEffect:
  5482.                     S = "Expected 'delayline', 'nlproc', 'filter', or 'analyzer'";
  5483.                     break;
  5484.             }
  5485.  
  5486.         return S;
  5487.     }
  5488.